From 7e5f1b9159ed869268354a33e0f14cd2e13d0680 Mon Sep 17 00:00:00 2001 From: Tollef Fog Heen Date: Thu, 17 Jul 2008 12:24:11 +0200 Subject: [PATCH 1/1] Initial import --- AUTHORS | 28 + ChangeLog | 229 + LICENSE | 281 + MD5SUMS | 60 + Makefile.dep.dist | 31 + Makefile.in | 74 + VERSION | 1 + aclocal.m4 | 294 + backuppcd-auth.c | 112 + backuppcd-auth.h | 21 + backuppcd-client.c | 494 + backuppcd-common.c | 44 + backuppcd-common.h | 141 + backuppcd-notify.c | 76 + backuppcd-notify.h | 6 + backuppcd-passwd.c | 48 + backuppcd-tar.c | 895 ++ backuppcd.c | 3879 ++++++++ backuppcd.conf | 14 + backuppcd.h | 156 + chown.c | 9 + chown.h | 12 + compat.h | 181 + config.guess | 1459 +++ config.h.in | 341 + config.sub | 1549 +++ configure | 22060 ++++++++++++++++++++++++++++++++++++++++++ configure.ac | 97 + doc/attrib.txt | 21 + doc/backuppcd.pdf | Bin 0 -> 123464 bytes doc/protocol.txt | 183 + fnmatch.c | 490 + fnmatch.h | 84 + gethostname.c | 32 + gethostname.h | 18 + htonll.c | 71 + htonll.h | 48 + install-sh | 251 + libbackuppc.c | 0 libbackuppc.h | 0 libbackuppcd.c | 1784 ++++ libbackuppcd.h | 102 + link.c | 22 + link.h | 15 + md4.c | 269 + md4.h | 42 + md5.c | 381 + md5.h | 107 + net.c | 162 + net.h | 41 + ntohll.c | 71 + ntohll.h | 49 + sha1.c | 221 + sha1.h | 18 + strsep.c | 13 + strsep.h | 8 + tools/.cvsignore | 2 + tools/file_sync.c | 585 ++ tools/notify-server | 189 + win32.h | 78 + 60 files changed, 37949 insertions(+) create mode 100644 AUTHORS create mode 100644 ChangeLog create mode 100644 LICENSE create mode 100644 MD5SUMS create mode 100644 Makefile.dep.dist create mode 100644 Makefile.in create mode 100644 VERSION create mode 100644 aclocal.m4 create mode 100644 backuppcd-auth.c create mode 100644 backuppcd-auth.h create mode 100644 backuppcd-client.c create mode 100644 backuppcd-common.c create mode 100644 backuppcd-common.h create mode 100644 backuppcd-notify.c create mode 100644 backuppcd-notify.h create mode 100644 backuppcd-passwd.c create mode 100644 backuppcd-tar.c create mode 100644 backuppcd.c create mode 100644 backuppcd.conf create mode 100644 backuppcd.h create mode 100644 chown.c create mode 100644 chown.h create mode 100644 compat.h create mode 100755 config.guess create mode 100644 config.h.in create mode 100755 config.sub create mode 100755 configure create mode 100644 configure.ac create mode 100644 doc/attrib.txt create mode 100644 doc/backuppcd.pdf create mode 100644 doc/protocol.txt create mode 100644 fnmatch.c create mode 100644 fnmatch.h create mode 100644 gethostname.c create mode 100644 gethostname.h create mode 100644 htonll.c create mode 100644 htonll.h create mode 100755 install-sh create mode 100644 libbackuppc.c create mode 100644 libbackuppc.h create mode 100644 libbackuppcd.c create mode 100644 libbackuppcd.h create mode 100644 link.c create mode 100644 link.h create mode 100644 md4.c create mode 100644 md4.h create mode 100644 md5.c create mode 100644 md5.h create mode 100644 net.c create mode 100644 net.h create mode 100644 ntohll.c create mode 100644 ntohll.h create mode 100644 sha1.c create mode 100644 sha1.h create mode 100644 strsep.c create mode 100644 strsep.h create mode 100644 tools/.cvsignore create mode 100644 tools/file_sync.c create mode 100755 tools/notify-server create mode 100644 win32.h diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..62e3b3b --- /dev/null +++ b/AUTHORS @@ -0,0 +1,28 @@ + BackupPC Daemon 200603161528 + +Release information: + pkg: BakcupPC Daemon version 200603161528 + url: http://www.rkeene.org/devel/backuppcd-200603161528.tar.gz + date: Thu Mar 16 15:28:44 CST 2006 + mail: backuppcd-bugs@psislidell.com + backuppcd@rkeene.org +author: Roy Keene + Planning Systems Inc. + Slidell, LA 70458 + United States +-------------------------------------------------------------------------- + +Primary Author: + Roy Keene + +Mac OS X Testing and Development: + Kenny VanAlstyne + +BackupPC Integration: + Craig Barratt + +Message-Digest 4 checksum algorithm copyright (C) 1991 - 1992, RSA Data +Security, Inc. All rights reserved. + +Message-Digest 5 checksum algorithm copyright (C) 1999 - 2002, Aladdin +Enterprises. All rights reserved. diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..59f8fff --- /dev/null +++ b/ChangeLog @@ -0,0 +1,229 @@ + BackupPC Daemon 200603161528 + +Release information: + pkg: BakcupPC Daemon version 200603161528 + url: http://www.rkeene.org/devel/backuppcd-200603161528.tar.gz + date: Thu Mar 16 15:28:44 CST 2006 + mail: backuppcd-bugs@psislidell.com + backuppcd@rkeene.org +author: Roy Keene + Planning Systems Inc. + Slidell, LA 70458 + United States +-------------------------------------------------------------------------- + +Tue, 14 Mar 2006 + * Added protocol definitions for a "HOSTNAME" command and reply. + * + * Updated backuppcd to attempt to be smarter about finding itself. + +Mon, 13 Mar 2006 + * BackupPCd 0.1.3 + * + * Added "--with-notifyserv" and "--with-updateurl" configuration options to + * hard-code their respective parameters as defaults into the resulting + * executable. + +Sun, 12 Mar 2006 + * Updated the "notify-server" to run in the foreground if Tclx is not available. + * + * Added a "gethostname()" replacement + * + * Added "backuppcd_notify()" and related code. No authentication is currently + * present. + * + * Created a small example "notify-server" in Tcl. This server just manipulates + * the "/etc/hosts" file. + +Sat, 11 Mar 2006 + * Changed file_sync to only lseek() when needed + * + * Added strsep() replacement code + * + * Modified build process to create Win32 binaries on release + * + * Added some comments to the sample configuration file + * + * Added stub for new configuration option "NotifyServer" + * + * Made backuppcd-passwd prompt for a password to be read froms stdin + +Mon, 30 Jan 2006 + * Changed the way "file_sync" works to a less latency-driven approach. + +Mon, 23 Jan 2006 + * Changed version to BackupPCd 0.1.2 + * + * Fixed authentication bug, where upon sucessful authentication the client + * was still rejected. + * + * Lots of work on backuppcd-client: It now stores the incoming data in an + * appropriate formatted directory structure; It can now check to see if + * a file exists before fetching it + * + * Created a backuppc-passwd program to accept a plaintext password as an + * argument and produce the SHA1 hash on stdout. + * + * Moved the "sha1sum" function to sha1.c and renamed it "SHA1sum" + * + * Minor fixes to link.h, win32.h + * + * Minor changes to file_sync.c: changed upper limit of internal write buffer + * to (INT_MAX-1); a bit of work on the weird collection of functions to write + * data to the network + * + * Added extra debug information to libbackuppcd.c (CHECKPOINT's everywhere.) + * + * Only attempt to set file permissions if the "preserve" flag is set + * in bpc_copyfile() + * + * Forced "RDIFF" check to fail in bpc_copyfile, so full copies will be made + * instead of attempting and failing diffs (RDIFF not implemented yet.) + * + * Fixed typo in documentation + * + * Moved backuppcd.pdf into doc/ upon tarball building. + * + * Added "attrib" file format description + +Wed, 18 Jan 2006 + * Fixed issue where LIBS were not deleted by the makefile's "clean" target + +Thu, 12 Jan 2006 + * Added authentication subsystem and updated example configuration file to + * reflect this change. + * + * Integrated authentication subsystem into backuppcd + +Tue, 6 Dec 2005 + * Fixed bug where large files would only send the lower 32bits of their + * filesize. + * + * BackupPCd 0.1.1 + +Mon, 5 Dec 2005 + * Fixed invalid free() calls. + +Mon, 28 Nov 2005 + * Added a "Priority" option to specify a priority for the process. + * + * Updated option callbacks to use a "_opt" prefix + * + * Updated list of ignored filesystems and added stubs for BSD getmntinfo() calls + * + * Updated win32 build to request mostly static build. + * + * Updated mostly static build to cross compile correctly. + * + * Added support for not recursing into NFS and procfs filesystems + * (possibly Linux-only?) + * + * Added an --enable-static option to build a mostly-static binary + * + * Made protocol documentation a bit more consistent. + * + * Updated file_sync + +Thu, 25 Aug 2005 + * Added a "tools" directory. + * + * Created an object in the tools directory called "file_sync.c" which is a + * simplistic single-file sync tool. + * + * This project now requires GNU make to build (other makes may do strange + * things to the "tools/file_sync" target) + +Wed, 24 Aug 2005 + * Added documentation comments to libbbackuppcd + * + * Changed the type for the `buf' parameter to bpc_get() from (char *) to + * (void *) + +Tue, 23 Aug 2005 + * Updated stub link() replacement to work under Win32 (in NT5 and up) + * + * Added fnmatch code from GNU make (3.80) to work around systems lacking it. It + * compiles, and may even work. + * + * Updated AUTHORS to more closely match the required text for MD4 and MD5 + * licenses. + * + * Added support for ".bpc" directive files for specifying to exclude and + * include files for backing up. + * + * Wrote a stub fnmatch for platforms without it (Win32) + * + * Added Win32 executables to the svn:ignore property and .cvsignore file + * + * Updated BackupPCd to use the "makearch" supplied ChangeLog generation + * mechanism. + +Mon, 22 Aug 2005 + * Added a "build_changelog" script to convert and sanitize the "svn log" output. + * + * Modified the build script to run "build_changelog" when doing a release. + * + * Many changes. + * + * Removed "md4_rsync" hashing support, as it's not needed. + * + * Added a BackupPCd LyX document, updated the build script to build a PDF from + * this document. + * + * Updated the RDIFF protocol documentation slightly. + * + * Added support for sending file hashes during a LIST or GET as part of the + * options parameter. + * + * Added support for sending the hash as a BPC hash. + * + * Updated the client to somewhat take advantage of these hashes. + +Fri, 19 Aug 2005 + * Added MD5 (LPD, some guy) support + * + * Added MD4 (RSA) and MD5 (LPD, some guy) support + * + * Updated authors to indicate MD5 and MD4 ownership + * + * Added a stub "libbackuppc" for BackupPC specific stuff + +Mon, 15 Aug 2005 + * Many changes: + * + * Removed compiled "configure" script from version control. + * + * Added wrapper calls for link() and chown() for OSes who lack it. + * + * Added a dummy md4_rsync.c in preparation for supporting RSYNC's + * broken MD4 algorithm. + * + * libbackuppcd is now functional + * + * Removed an unused item from the backuppc_dirent structure in backuppcd + * + * Rewrote backuppcd-client to use libbackuppcd + +Thu, 11 Aug 2005 + * Updated BackupPCd to check for overflows in the directory-following code + * + * Fixed a couple of bugs in the BackupPCd server: + * Reading from a free()'d memory region in the connection cleanup section. + * Not updating the "symlinkdest" dirent value when a symbolic link's + * destination could not be read with readlink(). + * + * Fixed a memory leak and changed default port to the preprocessor macro. + +Wed, 10 Aug 2005 + * Many updates, brought the project to a usable form and have begun writing + * a library (libbackuppcd) to update the "backuppcd-client" to the official + * BackupPC-BackupPCd client. + +Thu, 7 Jul 2005 + * BackupPCd 0.0.26 + * + * First public release. + +Sat, 25 Jun 2005 + * Added BackupPC daemon project. + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e3f99ff --- /dev/null +++ b/LICENSE @@ -0,0 +1,281 @@ +GNU GENERAL PUBLIC LICENSE + + Version 2, June 1991 +Copyright (C) 1989, 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. + +Preamble + + The licenses for most software are designed to take away your freedom + to share and change it. By contrast, the GNU General Public License is + intended to guarantee your freedom to share and change free + software--to make sure the software is free for all its users. This + General Public License applies to most of the Free Software + Foundation's software and to any other program whose authors commit to + using it. (Some other Free Software Foundation software is covered by + the GNU Library General Public License instead.) You can apply it to + your programs, 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 software, or if you modify it. + + For example, if you distribute copies of such a program, whether + gratis or for a fee, you must give the recipients all the rights that + you have. You must make sure that they, too, receive or can get the + source code. And you must show them these terms so they know their + rights. + + We protect your rights with two steps: (1) copyright the software, and + (2) offer you this license which gives you legal permission to copy, + distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain + that everyone understands that there is no warranty for this free + software. If the software is modified by someone else and passed on, + we want its recipients to know that what they have is not the + original, 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 redistributors of a free + program will individually obtain patent licenses, in effect making the + program proprietary. To prevent this, we have made it clear that any + patent must be licensed for everyone's free use or not licensed at + all. + + The precise terms and conditions for copying, distribution and + modification follow. + +TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains a + notice placed by the copyright holder saying it may be distributed + under the terms of this General Public License. The "Program", below, + refers to any such program or work, and a "work based on the Program" + means either the Program or any derivative work under copyright law: + that is to say, a work containing the Program or a portion of it, + either verbatim or with modifications and/or translated into another + language. (Hereinafter, translation is included without limitation in + the term "modification".) Each licensee is addressed as "you". + + Activities other than copying, distribution and modification are not + covered by this License; they are outside its scope. The act of + running the Program is not restricted, and the output from the Program + is covered only if its contents constitute a work based on the Program + (independent of having been made by running the Program). Whether that + is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's 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 give any other + recipients of the Program a copy of this License along with the + Program. + + 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 Program or any portion of + it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + * b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + * c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but does + not normally print such an announcement, your work based on the + Program is not required to print an announcement.) + + These requirements apply to the modified work as a whole. If + identifiable sections of that work are not derived from the Program, + 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 Program, 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 Program. + + In addition, mere aggregation of another work not based on the Program + with the Program (or with a work based on the Program) on a volume of + a storage or distribution medium does not bring the other work under + the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, + under Section 2) in object code or executable form under the terms of + Sections 1 and 2 above provided that you also do one of the following: + * a) 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; or, + * b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + * c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + + The source code for a work means the preferred form of the work for + making modifications to it. For an executable work, 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 executable. 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. + + If distribution of executable or 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 counts as + distribution of the source code, even though third parties are not + compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program + except as expressly provided under this License. Any attempt otherwise + to copy, modify, sublicense or distribute the Program 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. + + 5. 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 Program or its derivative works. These actions are + prohibited by law if you do not accept this License. Therefore, by + modifying or distributing the Program (or any work based on the + Program), you indicate your acceptance of this License to do so, and + all its terms and conditions for copying, distributing or modifying + the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the + Program), the recipient automatically receives a license from the + original licensor to copy, distribute or modify the Program 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. + + 7. 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 Program at all. For example, if a patent + license would not permit royalty-free redistribution of the Program 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 Program. + + 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. + + 8. If the distribution and/or use of the Program is restricted in + certain countries either by patents or by copyrighted interfaces, the + original copyright holder who places the Program 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. + + 9. The Free Software Foundation may publish revised and/or new + versions of the 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 Program + 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 Program does not specify a + version number of this License, you may choose any version ever + published by the Free Software Foundation. + + 10. If you wish to incorporate parts of the Program into other free + programs whose distribution conditions are different, 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 + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO + WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. + EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR + OTHER PARTIES PROVIDE THE PROGRAM "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 + PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME + THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 12. 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 PROGRAM 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 + PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF + SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + DAMAGES. + +END OF TERMS AND CONDITIONS + diff --git a/MD5SUMS b/MD5SUMS new file mode 100644 index 0000000..1d33706 --- /dev/null +++ b/MD5SUMS @@ -0,0 +1,60 @@ +43f8e335618ffb096ba70507b2644e88 AUTHORS +d41d8cd98f00b204e9800998ecf8427e MD5SUMS +f21bfb75508ff5fce435e1c5e9133500 LICENSE +5463692cb7f450ac5c2231dac388e9ad VERSION +36186d76a642fbe2071099fd932b99bf Makefile.dep.dist +46e7d35a6d5c376c50cc173a3e4f9a8a Makefile.in +bed720949c9a36e5bd2d5f56a9de3448 aclocal.m4 +825d82bbb51a73b1199fd644c45803a6 backuppcd-auth.c +46ae9d354fd45d836a64788b9e544517 backuppcd-auth.h +95b1506d3646446c7f8e07c9a04280d4 backuppcd-client.c +70e66fc0620da4bc7e3ff842633cb1e1 backuppcd-common.c +da0a97fc76089e32a7e5840a1754e07c backuppcd-common.h +9841ab5be0b4bd0886bdb81f392b2037 backuppcd-notify.c +d6d2187d8b00ca76205cef794693a466 backuppcd-notify.h +0b1825a8e4180f80e81024ae6321ce34 backuppcd-passwd.c +461df0fac6e737d869ad092771cca897 backuppcd-tar.c +4e0d01d7a31abebbb3e29f04473a7759 backuppcd.c +e825768243880b6733f2da0f79112278 backuppcd.conf +28735ba26f22a40451f67aa29515fc11 backuppcd.h +1126e21a0c65bf02582ec0d4734a56a6 chown.c +b39a4a242ff3c692d880c6971a0f8708 chown.h +6be84128197531606a85157492a15159 compat.h +24cc880101f03147b04e06e386c45050 config.guess +ca8d5e92267f78a20028f88fcc999f5f config.h.in +5efd4f335eaecca6a494fd65b2ea64da config.sub +8794c5c4b7c0ed0e50e0f40281ce5d4f configure +2cb05fe1ea46f3d27d4308e75847ed42 configure.ac +727e0415c73a362ca2d1b51d7b052795 doc/protocol.txt +87ea52be177c7f9323b4ca6dd947f5b5 doc/attrib.txt +da56c3dcef34c67b56b1c28a144d9488 doc/backuppcd.pdf +35f9a22f94a77a57053e92bff3db963c fnmatch.c +eccffb27cd6258577798c24cd756354c fnmatch.h +dc03cfd034b4d3b932a936692aefc960 gethostname.c +f955e3be8b6163dda778778b8dee481e gethostname.h +37acef1fe1de5abdca58457cca037a87 htonll.c +9f968debccc2fe4490b250fee99b3607 htonll.h +5afe8eb5573965dfb58378e4e46f3813 install-sh +d41d8cd98f00b204e9800998ecf8427e libbackuppc.c +d41d8cd98f00b204e9800998ecf8427e libbackuppc.h +f0640f8812a56248d01cbe172d6ffc9d libbackuppcd.c +e2de8cb94a6fa3c9ec738247302f903c libbackuppcd.h +0b2057f3a8499c49ea48cca4bb123230 link.c +acd058cbe3ee727ad61378717b3233b6 link.h +a164c7f2d95c047ab65d656856024ae5 md4.c +d85af2b28a8dedde39bc3babbb900a63 md4.h +20047d847779331026450f16643acebc md5.c +73d779efd2b96a26713803ca2711e800 md5.h +212f55e63bb5131dc2f49959f31e639a net.c +9bc26115fc5880167c7c233b89b84729 net.h +4025c5e5b62d29b2969596efaff81307 ntohll.c +328a19245415cbc61b411e5755bcfb15 ntohll.h +ef0c30949eaa27892a4e31d904d73a48 sha1.c +7dfb53b50871532d48541952bfc7042f sha1.h +d7935409ffb480fc39105bc58f39b4a9 strsep.c +6088f2bf3347c1a47fb700eb9f7ee934 strsep.h +f0734e8d4bf99777f7d2f83984562740 tools/file_sync.c +6c44fd064631c7a0f57fc18e19b4f840 tools/notify-server +d5c548ec608de4bef8d7b65bf2da174a tools/.cvsignore +929feccce3a4e5c68dad9639ed8a8bd5 win32.h +55de175ea078e2d8b919aadf002cc124 ChangeLog diff --git a/Makefile.dep.dist b/Makefile.dep.dist new file mode 100644 index 0000000..670fb2f --- /dev/null +++ b/Makefile.dep.dist @@ -0,0 +1,31 @@ +backuppcd-auth.o: backuppcd-auth.c compat.h win32.h config.h htonll.h ntohll.h \ + backuppcd-auth.h +backuppcd-client.o: backuppcd-client.c compat.h win32.h config.h htonll.h \ + ntohll.h backuppcd-common.h +backuppcd-common.o: backuppcd-common.c compat.h win32.h config.h htonll.h \ + ntohll.h backuppcd-common.h +backuppcd-notify.o: backuppcd-notify.c compat.h win32.h config.h htonll.h \ + ntohll.h net.h +backuppcd-passwd.o: backuppcd-passwd.c compat.h win32.h config.h htonll.h \ + ntohll.h sha1.h +backuppcd-tar.o: backuppcd-tar.c compat.h win32.h config.h htonll.h ntohll.h \ + backuppcd.h backuppcd-common.h net.h +backuppcd.o: backuppcd.c compat.h win32.h config.h htonll.h ntohll.h backuppcd.h \ + backuppcd-common.h backuppcd-auth.h backuppcd-notify.h net.h sha1.h \ + md4.h md5.h +chown.o: chown.c chown.h compat.h win32.h config.h htonll.h ntohll.h backuppcd.h \ + backuppcd-common.h +fnmatch.o: fnmatch.c compat.h win32.h config.h htonll.h ntohll.h +gethostname.o: gethostname.c compat.h win32.h config.h htonll.h ntohll.h +htonll.o: htonll.c compat.h win32.h config.h htonll.h ntohll.h +libbackuppc.o: libbackuppc.c +libbackuppcd.o: libbackuppcd.c compat.h win32.h config.h htonll.h ntohll.h \ + backuppcd.h backuppcd-common.h libbackuppcd.h sha1.h net.h +link.o: link.c compat.h win32.h config.h htonll.h ntohll.h link.h backuppcd.h \ + backuppcd-common.h +md4.o: md4.c md4.h compat.h win32.h config.h htonll.h ntohll.h +md5.o: md5.c md5.h compat.h win32.h config.h htonll.h ntohll.h +net.o: net.c compat.h win32.h config.h htonll.h ntohll.h net.h +ntohll.o: ntohll.c compat.h win32.h config.h htonll.h ntohll.h +sha1.o: sha1.c compat.h win32.h config.h htonll.h ntohll.h sha1.h +strsep.o: strsep.c diff --git a/Makefile.in b/Makefile.in new file mode 100644 index 0000000..df50131 --- /dev/null +++ b/Makefile.in @@ -0,0 +1,74 @@ +prefix = @prefix@ +mandir = @mandir@ +sysconfdir = @sysconfdir@ +datadir = @datadir@ +exec_prefix = @exec_prefix@ +bindir = @bindir@ +libdir = @libdir@ +localstatedir = @localstatedir@ + +CC = @CC@ +CFLAGS = -Wall -Os @CFLAGS@ @DEFS@ -I. +CPPFLAGS = @CPPFLAGS@ @DEFS@ "-DSYSCONFDIR=\"$(sysconfdir)\"" "-DBACKUPPC_PIDFILE=\"$(localstatedir)/run/backuppcd.pid\"" "-DEXEEXT=\"$(EXEEXT)\"" "-DEXECPREFIX=\"$(exec_prefix)\"" -I. +LDFLAGS = @LDFLAGS@ @LIBS@ +INSTALL = @INSTALL@ +EXEEXT = @EXEEXT@ +OBJEXT = @OBJEXT@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +AR = @AR@ +RANLIB = @RANLIB@ +AREXT = @AREXT@ + + +BINS = backuppcd$(EXEEXT) backuppcd-client$(EXEEXT) backuppcd-tar$(EXEEXT) backuppcd-passwd$(EXEEXT) tools/file_sync$(EXEEXT) +LIBS = libbackuppcd$(AREXT) libbackuppc$(AREXT) + +all: $(BINS) $(LIBS) + +backuppcd$(EXEEXT): Makefile.dep backuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o backuppcd-auth.o backuppcd-notify.o @LIBOBJS@ + $(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd$(EXEEXT) backuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o backuppcd-auth.o backuppcd-notify.o @LIBOBJS@ $(LDFLAGS) + +backuppcd-client$(EXEEXT): Makefile.dep libbackuppcd$(AREXT) libbackuppc$(AREXT) backuppcd-client.o + $(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-client$(EXEEXT) backuppcd-client.o -L. -lbackuppcd -lbackuppc $(LDFLAGS) + +backuppcd-tar$(EXEEXT): Makefile.dep backuppcd-tar.o net.o backuppcd-common.o sha1.o @LIBOBJS@ + $(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-tar$(EXEEXT) backuppcd-tar.o net.o backuppcd-common.o sha1.o @LIBOBJS@ $(LDFLAGS) + +backuppcd-passwd$(EXEEXT): Makefile.dep backuppcd-passwd.o sha1.o + $(CC) $(CPPFLAGS) $(CFLAGS) -o backuppcd-passwd$(EXEEXT) backuppcd-passwd.o sha1.o $(LDFLAGS) + +tools/file_sync$(EXEEXT): Makefile.dep tools/file_sync.o net.o md4.o @LIBOBJS@ + $(CC) $(CPPFLAGS) $(CFLAGS) -I.. -o tools/file_sync$(EXEEXT) tools/file_sync.o net.o md4.o @LIBOBJS@ -L.. $(LDFLAGS) + +libbackuppcd$(AREXT): Makefile.dep libbackuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o @LIBOBJS@ + $(AR) rcu libbackuppcd$(AREXT) libbackuppcd.o net.o backuppcd-common.o sha1.o md4.o md5.o @LIBOBJS@ + $(RANLIB) libbackuppcd$(AREXT) + +libbackuppc$(AREXT): Makefile.dep libbackuppc.o sha1.o md4.o md5.o + $(AR) rcu libbackuppc$(AREXT) libbackuppc.o sha1.o md4.o md5.o + $(RANLIB) libbackuppc$(AREXT) + +Makefile.dep: + -$(CC) $(CFLAGS) $(CPPFLAGS) -MM *.c > Makefile.dep + -$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -MM tools/*.c >> Makefile.dep + -@test -s Makefile.dep || cp Makefile.dep.dist Makefile.dep + +-include Makefile.dep + +.PHONY: clean distclean install +clean: + rm -f tools/*.o *.o $(BINS) $(LIBS) *~ + +distclean: clean + rm -f Makefile config.h config.status config.log Makefile.dep + +install: all + -$(INSTALL) -d $(bindir) + -$(INSTALL) -d $(libdir) + -$(INSTALL) -d $(prefix)/include + $(INSTALL) -m 755 backuppcd$(EXEEXT) $(bindir)/backuppcd$(EXEEXT) + $(INSTALL) -m 644 libbackuppcd$(AREXT) $(libdir)/libbackuppcd$(AREXT) + $(INSTALL) -m 644 libbackuppc$(AREXT) $(libdir)/libbackuppc$(AREXT) + $(INSTALL) -m 644 backuppcd.h $(prefix)/include/backuppcd.h + $(INSTALL) -m 644 libbackuppcd.h $(prefix)/include/libbackuppcd.h + $(INSTALL) -m 644 libbackuppc.h $(prefix)/include/libbackuppc.h diff --git a/VERSION b/VERSION new file mode 100644 index 0000000..e2e7ef9 --- /dev/null +++ b/VERSION @@ -0,0 +1 @@ +SNAPSHOT. diff --git a/aclocal.m4 b/aclocal.m4 new file mode 100644 index 0000000..9acb1e0 --- /dev/null +++ b/aclocal.m4 @@ -0,0 +1,294 @@ +AC_DEFUN(DC_DO_NETWORK, [ + + AC_CHECK_HEADERS(arpa/inet.h errno.h fcntl.h netdb.h netinet/in.h stdarg.h stdio.h stdlib.h string.h sys/socket.h sys/stat.h sys/types.h unistd.h) + + AC_CHECK_TYPE(socklen_t, [ + AC_DEFINE(HAVE_SOCKLEN_T, [1], [Define to 1 if you have the "socklen_t" type.]) + ], [ + AC_DEFINE(NEED_SOCKLEN_T, [1], [Define to 1 if you need the "socklen_t" type.]) + ], [ +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif + ]) + + AC_SEARCH_LIBS(inet_aton, xnet ws2_32 wsock32, [ + AC_DEFINE(HAVE_INET_ATON, [1], [Have inet_aton()]) + ], [ + AC_SEARCH_LIBS(inet_addr, nsl ws2_32 wsock32, [ + AC_DEFINE(HAVE_INET_ADDR, [1], [Have inet_addr()]) + ], [ + AC_MSG_WARN([Couldn't find inet_addr or inet_aton]) + ]) + ]) + AC_SEARCH_LIBS(connect, socket nsl ws2_32 wsock32,, [ AC_MSG_WARN([Couldn't find connect]) ]) + AC_SEARCH_LIBS(inet_ntoa, socket nsl ws2_32 wsock32,, [ AC_MSG_WARN([Couldn't find inet_ntoa]) ]) +]) + +AC_DEFUN(DC_DO_WIN32, [ + AC_CHECK_HEADERS(windows.h windowsx.h winsock2.h) + + AC_CHECK_LIB(wsock32, main, [ + AC_DEFINE(HAVE_LIBWSOCK32, [1], [Have libwsock32]) + LIBS="${LIBS} -lwsock32" + ]) +]) + +AC_DEFUN(DC_DO_TYPE, [ + if test -z "$ac_cv_sizeof_long"; then + AC_C_INLINE + AC_CHECK_SIZEOF(long long, 8) + AC_CHECK_SIZEOF(long, 4) + AC_CHECK_SIZEOF(int, 4) + AC_CHECK_SIZEOF(short, 2) + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "$3"; then + if test "$dc_cv_name" = "int"; then + AC_CHECK_TYPE($1, $2 int) + fi + if test "$dc_cv_name" = "long"; then + AC_CHECK_TYPE($1, $2 long) + fi + if test "$dc_cv_name" = "long_long"; then + AC_CHECK_TYPE($1, $2 long long) + fi + if test "$dc_cv_name" = "short"; then + AC_CHECK_TYPE($1, $2 short) + fi + FOUND=1 + break + fi + done +]) + +AC_DEFUN(DC_SETLDRUNPATH, [ + OLD_LDFLAGS="$LDFLAGS" + + LDRUNPATH="" + for testldflags in "-Wl,-rpath -Wl,$1" "-Wl,-R -Wl,$1"; do + LDFLAGS="$OLD_LDFLAGS $testldflags" + AC_TRY_LINK([#include ], + [ return(0); ], [ LDRUNPATH="$LDRUNPATH $testldflags"; break ]); + done + + LDFLAGS="$OLD_LDFLAGS" + if test -n "$LDRUNPATH"; then + LDFLAGS="$LDRUNPATH $LDFLAGS" + fi +]) + + +AC_DEFUN(DC_ASK_OPTLIB, [ + LIBSPECLIBDIR="" + AC_ARG_WITH($5, AC_HELP_STRING(--with-$5, $4), [ +# Specified + LIBSPEC=$withval + ], [ +# Not specified + LIBSPECFLAGS="`pkg-config --libs $5 2>/dev/null`" + LIBSPECCFLAGS="`pkg-config --cflags $5 2>/dev/null`" + AC_CHECK_LIB($1, $2, [ + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "$3" ; then + AC_CHECK_HEADER($3, [ + LIBSPEC=yes + ], [ + LIBSPEC=no + ]) + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + ], [ + if test -n "$8"; then + + dnl The next line hopefully just invalidates the cache. + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="$8 $LIBSPECFLAGS" + AC_CHECK_LIB($1, $2, [ + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "$3" ; then + AC_CHECK_HEADER($3, [ + LIBSPEC=yes + ], [ + LIBSPEC=no + ]) + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + ], [ + dnl The next line hopefully just invalidates the cache. + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="$8" + AC_CHECK_LIB($1, $2, [ + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "$3" ; then + AC_CHECK_HEADER($3, [ + LIBSPEC=yes + ], [ + LIBSPEC=no + ]) + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + ], [ + LIBSPEC=no + $9 + AC_MSG_WARN(Did not find $5) + ], $LIBSPECFLAGS) + ], $LIBSPECFLAGS) + else + LIBSPEC=no + $9 + AC_MSG_WARN(Did not find $5) + fi + ], $LIBSPECFLAGS) + ]) + case $LIBSPEC in + no) + $9 + AC_MSG_WARN(Support for $5 disabled) + ;; + *) + if test "${LIBSPEC}" = "yes"; then + true + else + LIBSPECLIBDIR="${LIBSPEC}/lib" + LIBSPECFLAGS="-L${LIBSPEC}/lib ${LIBSPECFLAGS}" + LIBSPECCFLAGS="-I${LIBSPEC}/include ${LIBSPECCFLAGS}" + fi + AC_CHECK_LIB($1, $2, [ + OLDCFLAGS="$CFLAGS" + OLDCPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS ${LIBSPECCFLAGS}" + CFLAGS="$CFLAGS ${LIBSPECCFLAGS}" + if test -n "$3"; then + AC_CHECK_HEADER($3, [ + headerok="yes" + ], [ + headerok="no" + ]) + else + headerok="yes" + fi + + if test $headerok = "yes"; then + if test -n "$7" -a -n "$3"; then + AC_DEFINE($7, [1], [Define to 1 if you have the <$3> header file.]) + fi + if test -n "$6" -a -n "$2"; then + AC_DEFINE($6, [1], [Define to 1 if you have $2 from $5]) + fi + LDFLAGS="$LIBSPECFLAGS $LDFLAGS" + if test -n "$LIBSPECLIBDIR"; then + DC_SETLDRUNPATH($LIBSPECLIBDIR) + fi + LIBS="-l$1 $LIBS" + else + CFLAGS="$OLDCFLAGS" + CPPFLAGS="$OLDCPPFLAGS" + $9 + AC_MSG_ERROR(Could not find $3) + fi + ], [ + AC_MSG_ERROR(Could not find $5) + ], $LIBSPECFLAGS) + ;; + esac +]) + +AC_DEFUN(DC_CHK_OS_INFO, [ + AC_CANONICAL_HOST + AC_SUBST(CFLAGS) + AC_SUBST(CPPFLAGS) + AC_SUBST(AREXT) + + AC_MSG_CHECKING(host operating system) + AC_MSG_RESULT($host_os) + + AREXT=".a" + + case $host_os in + mingw32msvc*) + CFLAGS="$CFLAGS -mno-cygwin -mms-bitfields" + CPPFLAGS="$CPPFLAGS -mno-cygwin -mms-bitfields" + ;; + cygwin*) + CFLAGS="$CFLAGS -mms-bitfields" + CPPFLAGS="$CPPFLAGS -mms-bitfields" + ;; + + esac +]) + +AC_DEFUN(DC_MAKE_STATIC, [ + AC_SUBST(LIBS) + AC_SUBST(LDFLAGS) + NEWLIBS="" + NEWLDFLAGS="" + + rm -f conftest conftest.c + cat <<\_ACEOF > conftest.c +#include +int main(void) { return(0); } +_ACEOF + "$CC" -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.c $LIBS >/dev/null 2>/dev/null + if test -e conftest; then + if test -z "$LDD"; then + LDD=`echo "$CC" | sed 's@gcc$[@]ldd@'` + if test "$LDD" = "$CC"; then + LDD=`echo "$CC" | sed 's@cc$[@]ldd@'` + fi + if test "$LDD" = "$CC"; then + LDD=false + fi + fi + "$LDD" conftest 2>/dev/null >conftest.ldd + fi + rm -f conftest conftest.c + + if test -e conftest.ldd; then + for lib in $LIBS; do + if echo "$lib" | grep '\-l' >/dev/null; then + libname=`echo "$lib" | sed 's@^-l@@'` + testlib=`cat conftest.ldd | awk '{ print $[3] }' | sed 's@\..*$[@]@' | grep "/lib$libname$"`.a + if test -e "$testlib" -a -n "$testlib"; then + lib="$testlib" + fi + fi + NEWLIBS="$NEWLIBS $lib" + done + for lib in $LDFLAGS; do + if echo "$lib" | grep '\-l' >/dev/null; then + libname=`echo "$lib" | sed 's@^-l@@'` + testlib=`cat conftest.ldd | awk '{ print $[3] }' | sed 's@\..*$[@]@' | grep "/lib$libname$"`.a + if test -e "$testlib" -a -n "$testlib"; then + lib="$testlib" + fi + fi + NEWLDFLAGS="$NEWLDFLAGS $lib" + done + + LIBS="$NEWLIBS" + LDFLAGS="$NEWLDFLAGS" + fi + + rm -f conftest.ldd +]) diff --git a/backuppcd-auth.c b/backuppcd-auth.c new file mode 100644 index 0000000..91e35db --- /dev/null +++ b/backuppcd-auth.c @@ -0,0 +1,112 @@ +#include "compat.h" +#include +#include "backuppcd-auth.h" + +struct bpcd_auth_userinfo; +struct bpcd_auth_userinfo { + const char *username; + const char *passhash; + backuppc_privs_t privs; + struct bpcd_auth_userinfo *_next; +}; + +struct bpcd_auth_userinfo *userlist = NULL; + +static int bpcd_auth_opt_user(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { + struct bpcd_auth_userinfo *newnode; + char *valcopy_s, *valcopy; + char *privstr; + + newnode = malloc(sizeof(*newnode)); + if (newnode == NULL) { + return(LC_CBRET_ERROR); + } + + valcopy_s = valcopy = strdup(value); + + newnode->username = strsep(&valcopy, " ,\t"); + if (newnode->username == NULL) { + free(valcopy_s); + free(newnode); + fprintf(stderr, "error: usage: USER \n"); + return(LC_CBRET_ERROR); + } + + newnode->passhash = strsep(&valcopy, " ,\t"); + if (newnode->passhash == NULL) { + free(valcopy_s); + free(newnode); + fprintf(stderr, "error: usage: USER \n"); + return(LC_CBRET_ERROR); + } + + privstr = strsep(&valcopy, " ,\t"); + if (privstr == NULL) { + free(valcopy_s); + free(newnode); + fprintf(stderr, "error: usage: USER \n"); + return(LC_CBRET_ERROR); + } + + if (strlen(newnode->passhash) != 40) { + free(valcopy_s); + free(newnode); + fprintf(stderr, "error: Password hash must be exactly 40 charectars long.\n"); + return(LC_CBRET_ERROR); + } + + if (strcasecmp(privstr, "Read") == 0) { + newnode->privs = BPC_PRIV_READ; + } else if (strcasecmp(privstr, "Write") == 0) { + newnode->privs = BPC_PRIV_WRITE; + } else if (strcasecmp(privstr, "ReadWrite") == 0) { + newnode->privs = BPC_PRIV_RDWR; + } else if (strcasecmp(privstr, "RD") == 0) { + newnode->privs = BPC_PRIV_READ; + } else if (strcasecmp(privstr, "WR") == 0) { + newnode->privs = BPC_PRIV_WRITE; + } else if (strcasecmp(privstr, "RDWR") == 0) { + newnode->privs = BPC_PRIV_RDWR; + } else if (strcasecmp(privstr, "r") == 0) { + newnode->privs = BPC_PRIV_READ; + } else if (strcasecmp(privstr, "w") == 0) { + newnode->privs = BPC_PRIV_WRITE; + } else if (strcasecmp(privstr, "rw") == 0) { + newnode->privs = BPC_PRIV_RDWR; + } else { + free(valcopy_s); + free(newnode); + fprintf(stderr, "error: usage: Privileges must be one of: READ, WRITE, or READWRITE\n"); + return(LC_CBRET_ERROR); + } + + newnode->_next = userlist; + userlist = newnode; + + return(LC_CBRET_OKAY); +} + +void bpcd_auth_init(void) { + lc_register_callback("User", 'u', LC_VAR_STRING, bpcd_auth_opt_user, NULL); + return; +} + +backuppc_privs_t bpcd_auth_verify(const char *username, const char *passhash, uint32_t address) { + struct bpcd_auth_userinfo *tmp; + + for (tmp = userlist; tmp; tmp = tmp->_next) { + + /* + * Should the username be case-sensitive ? (XXX) + */ + if (strcasecmp(tmp->username, username) == 0) { + if (strcasecmp(tmp->passhash, passhash) == 0) { + return(tmp->privs); + } else { + return(BPC_PRIV_ERROR); + } + } + } + + return(BPC_PRIV_ERROR); +} diff --git a/backuppcd-auth.h b/backuppcd-auth.h new file mode 100644 index 0000000..72818ee --- /dev/null +++ b/backuppcd-auth.h @@ -0,0 +1,21 @@ +#ifndef _RSK_BACKUPPCD_AUTH_H +#define _RSK_BACKUPPCD_AUTH_H 1 + +#include "compat.h" + +/* + * These define the different privilege levels for a connection to be assigned. + */ +typedef enum { + BPC_PRIV_ERROR, + BPC_PRIV_NONE, + BPC_PRIV_READ, + BPC_PRIV_WRITE, + BPC_PRIV_RDWR +} backuppc_privs_t; + + +void bpcd_auth_init(void); +backuppc_privs_t bpcd_auth_verify(const char *username, const char *passhash, uint32_t address); + +#endif diff --git a/backuppcd-client.c b/backuppcd-client.c new file mode 100644 index 0000000..3c8b239 --- /dev/null +++ b/backuppcd-client.c @@ -0,0 +1,494 @@ +#include "compat.h" +#include "backuppcd-common.h" +#include +#include + +/* XXX: include safety */ +#include +#include +#include + +#define BPC_CLIENT_LIST 0 +#define BPC_CLIENT_GET_INCR 1 +#define BPC_CLIENT_GET_FULL 2 + +static char *bpc_hashstr(const unsigned char hash[16]) { + static char ret[33]; + int i; + + for (i = 0; i < 16; i++) { + sprintf(ret + (i * 2), "%02x", hash[i]); + } + + return(ret); +} + +static char *bpc_poolpath(const char *pooldir, const unsigned char hash[16], int collidx) { + static char ret[8192]; + char *hashstr; + int snprintf_ret; + + hashstr = bpc_hashstr(hash); + + if (collidx < 0) { + snprintf_ret = snprintf(ret, sizeof(ret), "%s/%s", pooldir, hashstr); + } else { + snprintf_ret = snprintf(ret, sizeof(ret), "%s/%s_%i", pooldir, hashstr, collidx); + } + + if (snprintf_ret >= sizeof(ret)) { + return(NULL); + } + + return(ret); +} + +static char *bpc_mungepath(const char *path) { + static char ret[8192]; + char *path_cp, *path_cp_s; + char *retptr, *tmpbuf; + + if (!path) { + return(NULL); + } + + path_cp_s = path_cp = strdup(path); + retptr = ret; + ret[0] = '\0'; + + if (path[0] == '/') { + strcat(retptr, "f%2f"); + retptr += 4; + } + + for (; (tmpbuf = strsep(&path_cp, "/")) != NULL;) { + if (tmpbuf[0] == '\0') { + continue; + } + + *retptr = '/'; retptr++; + *retptr = 'f'; retptr++; + *retptr = '\0'; + strcat(retptr, tmpbuf); + retptr += strlen(tmpbuf); + } + + if (*retptr == '/') { + retptr--; + } + *retptr = '\0'; + + free(path_cp_s); + + return(ret); +} + +static int bpc_fileuptodate(const char *pooldir, const char *datadir, struct bpc_fileinfo *finfo) { + struct stat stbuf; + char localfile[8192]; + char *poolfile; + ino_t localinode, poolinode; + int retval = 0; + int snprintf_ret, stat_ret; + int i; + + snprintf_ret = snprintf(localfile, sizeof(localfile), "%s/%s", datadir, bpc_mungepath(finfo->name)); + if (snprintf_ret >= sizeof(localfile)) { + CHECKPOINT; + return(0); + } + + /* + * If the local file does not exist, do no further checking. + */ + stat_ret = stat(localfile, &stbuf); + if (stat_ret < 0) { + CHECKPOINT; + return(0); + } + + localinode = stbuf.st_ino; + + /* + * Iterate through all the available pool files to see if one matches + * our local file's inode + */ + for (i = -1; i < 0xffff; i++) { + poolfile = bpc_poolpath(pooldir, finfo->hash_bpc, i); + + stat_ret = stat(poolfile, &stbuf); + if (stat_ret < 0) { + CHECKPOINT; + break; + } + + poolinode = stbuf.st_ino; + + if (poolinode == localinode) { + CHECKPOINT; + retval = 1; + break; + } + } + + CHECKPOINT; + return(retval); +} +static int bpc_updatenewfilelist(FILE *fp, struct bpc_fileinfo *finfo) { + if (fp == NULL || finfo == NULL) { + return(-1); + } + + /* XXX: Check to make sure finfo->hash_bpc isn't non-sense */ + + + /* + * Print out the required data + */ + fprintf(fp, "%s %llu %s\n", bpc_hashstr(finfo->hash_bpc), finfo->size, bpc_mungepath(finfo->name)); + + return(0); +} + +static int bpc_updatexferlog(FILE *fp, struct bpc_fileinfo *finfo, ...) { + return(0); +} + +static int bpc_updateattrib(const char *pathname, struct bpc_fileinfo *finfo) { + static FILE *fp; + static char *lastdir = NULL; + size_t pathname_len; + char pathnameparent[16384], attribfile[16384], *tmp; + int snprintf_ret; + int needopen; + + if (pathname == NULL || finfo == NULL) { + return(-1); + } + + pathname_len = strlen(pathname) + 1; + + if (pathname_len >= sizeof(pathnameparent)) { + return(-1); + } + + memcpy(pathnameparent, pathname, pathname_len); + + tmp = strrchr(pathnameparent, '/'); + if (!tmp) { + return(-1); + } + + *tmp = '\0'; + + needopen = 1; + if (lastdir) { + if (strcmp(lastdir, pathnameparent) == 0) { + needopen = 0; + } + } + + if (needopen) { + snprintf_ret = snprintf(attribfile, sizeof(attribfile), "%s/attrib", lastdir); + if (snprintf_ret >= sizeof(attribfile)) { + return(-1); + } + + if (lastdir) { + free(lastdir); + } + if (fp) { + fclose(fp); + } + + lastdir = strdup(pathnameparent); + fp = fopen(attribfile, "w"); + } + + /* XXX: Write to attrib file */ + + return(0); +} + +static int print_help(const char *msg) { + if (msg) { + fprintf(stderr, "%s\n", msg); + } + + return(0); +} + +int main(int argc, char **argv) { + BPC_CONN *conn1, *conn2 = NULL; + struct bpc_fileinfo *finfo = NULL; + char *host = NULL, *command, *username = "anonymous", *password = NULL; + char localfile[16384]; + int snprintf_ret; + int port = BPC_TCP_PORT; + int mode; + int ret = 0; + char *run_curr = "new", *run_last = NULL; + int lc_ret; + int uptodate; + char type_string[][7] = {"dir", "file", "syml", "sock", "fifo", "blk", "chr", "hrdl"}; + char *pooldir = NULL; + char *datadir = NULL; + char lastdir[16384], currdir[16384]; + char newfilelistname[16384], xferfilename[16384]; + FILE *newfilelistfp = NULL; + + lc_register_var("Host", LC_VAR_STRING, &host, 'H'); + lc_register_var("Port", LC_VAR_INT, &port, 'P'); + lc_register_var("User", LC_VAR_STRING, &username, 'U'); + lc_register_var("Pass", LC_VAR_STRING, &password, 'p'); + lc_register_var("Pool", LC_VAR_STRING, &pooldir, 'S'); + lc_register_var("DataDir", LC_VAR_STRING, &datadir, 'D'); + lc_register_var("LastRun", LC_VAR_STRING, &run_last, 'r'); + lc_register_var("CurrRun", LC_VAR_STRING, &run_curr, 'R'); + + lc_ret = lc_process(argc, argv, "backuppcdc", LC_CONF_SPACE, NULL); + + lc_cleanup(); + + if (lc_ret != 0) { + fprintf(stderr, "Error processing configuration: %s\n", lc_geterrstr()); + return(EXIT_FAILURE); + } + + if (host == NULL) { + print_help("Host is required"); + return(EXIT_FAILURE); + } + if (password == NULL) { + print_help("Password is required"); + return(EXIT_FAILURE); + } + if (port < 0) { + print_help("Port is required"); + return(EXIT_FAILURE); + } + if (argc == lc_optind) { + print_help("Command is required"); + return(EXIT_FAILURE); + } + + command = argv[lc_optind]; + + if (strcasecmp(command, "list") == 0) { + mode = BPC_CLIENT_LIST; + } else if (strcasecmp(command, "get") == 0) { + mode = BPC_CLIENT_GET_INCR; + } else if (strcasecmp(command, "getfull") == 0) { + mode = BPC_CLIENT_GET_FULL; + } else { + fprintf(stderr, "Invalid operation: %s\n", command); + return(EXIT_FAILURE); + } + + switch (mode) { + case BPC_CLIENT_GET_INCR: + if (run_last == NULL) { + print_help("Last Run is required"); + return(EXIT_FAILURE); + } + if (pooldir == NULL) { + print_help("PoolDir is required"); + return(EXIT_FAILURE); + } + + case BPC_CLIENT_GET_FULL: + if (datadir == NULL) { + print_help("DataDir is required"); + return(EXIT_FAILURE); + } + + if (run_last != NULL) { + snprintf(lastdir, sizeof(lastdir), "%s/%s", datadir, run_last); + } + snprintf(currdir, sizeof(currdir), "%s/%s", datadir, run_curr); + snprintf(newfilelistname, sizeof(newfilelistname), "%s/NewFileList", datadir); + snprintf(xferfilename, sizeof(xferfilename), "%s/XferLOG", datadir); + newfilelistfp = fopen(newfilelistname, "w"); + } + + conn1 = bpc_connect(host, port, username, password); + if (!conn1) { + fprintf(stderr, "Failed (connect)\n"); + return(EXIT_FAILURE); + } + + /* + * Begin operation + */ + switch (mode) { + case BPC_CLIENT_LIST: + ret = bpc_list_open(conn1, "/", 1, BPC_HASH_NONE, NULL, NULL); + break; + case BPC_CLIENT_GET_INCR: + ret = bpc_list_open(conn1, "/", 1, BPC_HASH_BPC, NULL, NULL); + + conn2 = bpc_connect(host, port, username, password); + if (!conn2) { + fprintf(stderr, "Failed (connect)\n"); + return(EXIT_FAILURE); + } + break; + case BPC_CLIENT_GET_FULL: + ret = bpc_get_open(conn1, "/", 1, BPC_HASH_NONE, NULL, NULL); + break; + } + + if (!ret) { + fprintf(stderr, "Failed (open)\n"); + return(EXIT_FAILURE); + } + + /* + * Process every entry. + */ + while (1) { + switch (mode) { + case BPC_CLIENT_LIST: + finfo = bpc_list(conn1); + break; + case BPC_CLIENT_GET_INCR: + finfo = bpc_list(conn1); + break; + case BPC_CLIENT_GET_FULL: + finfo = bpc_get_head(conn1); + break; + } + + if (!finfo) { + printf("--- end ---\n"); + break; + } + + printf("[%4s] %06o %6lu %6lu %10llu %12lu (%s) %s", + type_string[finfo->type], + (unsigned int) finfo->mode, + (unsigned long) finfo->uid, + (unsigned long) finfo->gid, + (unsigned long long) finfo->size, + (unsigned long) finfo->mtime, + bpc_hashstr(finfo->hash_bpc), + finfo->name); + if (finfo->type == BPC_FILE_SYMLINK || finfo->type == BPC_FILE_HRDLINK) { + printf(" -> %s", finfo->linkdest); + } + printf("\n"); + + if (mode == BPC_CLIENT_LIST) { + continue; + } + + snprintf_ret = snprintf(localfile, sizeof(localfile), "%s/%s", currdir, bpc_mungepath(finfo->name)); + if (snprintf_ret < 0 || snprintf_ret >= sizeof(localfile)) { + PRINTERR("Filename too long. Something is almost definitely wrong, aborting."); + ret = 0; + CHECKPOINT; + break; + } + + switch (mode) { + case BPC_CLIENT_GET_INCR: + if (finfo->type == BPC_FILE_DIR) { + backuppc_mkdir(localfile); + } + + /* + * Update attrib file + */ + bpc_updateattrib(currdir, finfo); + + if (finfo->type != BPC_FILE_REG) { + break; + } + + /* + * Check to see if the file is up-to-date + */ + uptodate = bpc_fileuptodate(pooldir, lastdir, finfo); + if (uptodate) { + /* If so, don't copy it again. */ + break; + } + + /* + * Update NewFileList + */ + bpc_updatenewfilelist(newfilelistfp, finfo); + + CHECKPOINT; + SPOTVAR_S(finfo->name); + ret = bpc_get_open(conn2, finfo->name, 0, BPC_HASH_NONE, NULL, NULL); + CHECKPOINT; + if (!ret) { + CHECKPOINT; + break; + } + + CHECKPOINT; + finfo = bpc_get_head(conn2); + CHECKPOINT; + if (!finfo) { + ret = bpc_get_close(conn2); + CHECKPOINT; + break; + } + + ret = bpc_copyfile(conn2, finfo, localfile, 0); + if (!ret) { + CHECKPOINT; + } + + finfo = bpc_get_head(conn2); + if (finfo != NULL) { + ret = 0; + break; + } + + ret = bpc_get_close(conn2); + CHECKPOINT; + break; + case BPC_CLIENT_GET_FULL: + ret = bpc_copyfile(conn1, finfo, localfile, 0); + + CHECKPOINT; + break; + } + + if (!ret) { + printf("---- failed during file copy ----\n"); + break; + } + } + + /* + * Cleanup + */ + switch (mode) { + case BPC_CLIENT_LIST: + ret = bpc_list_close(conn1); + break; + case BPC_CLIENT_GET_INCR: + ret = bpc_list_close(conn1); + break; + case BPC_CLIENT_GET_FULL: + ret = bpc_get_close(conn1); + break; + } + + if (!ret) { + fprintf(stderr, "Failed (close).\n"); + return(EXIT_FAILURE); + } + + bpc_disconnect(conn1); + if (conn2) { + bpc_disconnect(conn2); + } + + fprintf(stderr, "Done.\n"); + return(EXIT_SUCCESS); +} diff --git a/backuppcd-common.c b/backuppcd-common.c new file mode 100644 index 0000000..95d7b74 --- /dev/null +++ b/backuppcd-common.c @@ -0,0 +1,44 @@ +#include "compat.h" +#include "backuppcd-common.h" + +int backuppc_mkdir(const char *dir) { + char *dircpy, *tmp;; + int retval; + +#ifdef MKDIR_TAKES_ONE_ARG + if (mkdir(dir) < 0) { +#else + if (mkdir(dir, 0700) < 0) { +#endif + dircpy = strdup(dir); + + tmp = dircpy; + + while (1) { + tmp = strchr(tmp + 1, '/'); + if (!tmp) { + break; + } + + *tmp = '\0'; +#ifdef MKDIR_TAKES_ONE_ARG + mkdir(dircpy); +#else + mkdir(dircpy, 0700); +#endif + *tmp = '/'; + } + + free(dircpy); + +#ifdef MKDIR_TAKES_ONE_ARG + retval = mkdir(dir); +#else + retval = mkdir(dir, 0700); +#endif + } else { + retval = 0; + } + + return(retval); +} diff --git a/backuppcd-common.h b/backuppcd-common.h new file mode 100644 index 0000000..cc9b5cd --- /dev/null +++ b/backuppcd-common.h @@ -0,0 +1,141 @@ +#ifndef _RSK_BACKUPPCD_COMMON_H +#define _RSK_BACKUPPCD_COMMON_H + +#include "compat.h" + +#ifdef HAVE_SYS_STAT_H +#include +#endif +#ifdef HAVE_FCNTL_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_STDIO_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif +#ifdef HAVE_STRINGS_H +#include +#endif +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_SIGNAL_H +#include +#endif +#ifdef HAVE_SYS_SELECT_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_FCNTL_H +#include +#endif +#ifdef HAVE_DIRENT_H +#include +#endif +#ifdef HAVE_CTYPE_H +#include +#endif +#ifdef HAVE_ASSERT_H +#include +#endif +#ifdef HAVE_STDARG_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_ARPA_INET_H +#include +#endif +#ifdef HAVE_LIBCONFIG +#include +#endif +#ifdef HAVE_LIBOPENNET +#include +#endif +#ifdef HAVE_SYSLOG_H +#include +#endif +#ifdef HAVE_UTIME_H +#include +#endif +#ifdef HAVE_TIME_H +#include +#else +#ifdef HAVE_SYS_TIME_H +#include +#endif +#endif + +#ifdef HAVE_LIBSSL +#ifndef NO_SSL +#if defined(HAVE_OPENSSL_SSL_H) +#include +#elif defined(HAVE_SSL_SSL_H) +#include +#elif defined(HAVE_SSL_H) +#include +#else +#define NO_SSL 1 +#endif +#endif +#else +#define NO_SSL 1 +#endif + +#ifndef NO_SSL +#define SSL 1 +#else +#undef SSL +#endif + +#ifndef HAVE_LINK +#include "link.h" +#endif +#ifndef HAVE_CHOWN +#include "chown.h" +#endif + +#ifndef HAVE_FNMATCH +#include "fnmatch.h" +#else +#ifdef HAVE_FNMATCH_H +#include +#endif +#endif + +#ifndef BPC_TCP_PORT +#define BPC_TCP_PORT 874 +#endif + +#ifndef BPC_TCP_NOTIFYPORT +#define BPC_TCP_NOTIFYPORT 899 +#endif + +#ifndef BPC_CONF_UPDATEURL +#define BPC_CONF_UPDATEURL NULL +#endif + +#ifndef BPC_CONF_NOTIFYSERV +#define BPC_CONF_NOTIFYSERV NULL +#endif + +int backuppc_mkdir(const char *dir); + +#endif diff --git a/backuppcd-notify.c b/backuppcd-notify.c new file mode 100644 index 0000000..d1fd405 --- /dev/null +++ b/backuppcd-notify.c @@ -0,0 +1,76 @@ +#include "compat.h" +#include "net.h" + +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_SYS_TYPES_H +#include +#endif + +#ifndef HOST_NAME_MAX +#define HOST_NAME_MAX 255 +#endif + +void backuppc_notify(const char *host, const int port, const char *overridehostname) { + static char *hostname = NULL; + char cmdbuf[8192], *cmdbuf_p; + size_t hostname_len; + ssize_t send_ret; + int chk_ret; + int sockfd; + + if (!host || port <= 0) { + return; + } + + if (overridehostname) { + hostname = (char *) overridehostname; + } + + if (!hostname) { + hostname_len = HOST_NAME_MAX + 1; + hostname = malloc(hostname_len); + if (hostname) { + chk_ret = gethostname(hostname, hostname_len); + if (chk_ret < 0) { + free(hostname); + hostname = NULL; + } + } + } + + if (!hostname) { + return; + } + + sockfd = net_connect_tcp(host, port); + if (sockfd >= 0) { + /* XXX: Authentiation ? */ + + /* Send hostname */ + chk_ret = snprintf(cmdbuf, sizeof(cmdbuf), "HOST %s\n", hostname); + if (chk_ret < sizeof(cmdbuf)) { + cmdbuf_p = cmdbuf; + + while (chk_ret) { + send_ret = send(sockfd, cmdbuf_p, chk_ret, 0); + + if (send_ret < 0) { + break; + } + + cmdbuf_p += send_ret; + chk_ret -= send_ret; + } + } + + net_close(sockfd); + } + + if (overridehostname) { + hostname = NULL; + } + + return; +} diff --git a/backuppcd-notify.h b/backuppcd-notify.h new file mode 100644 index 0000000..8051e68 --- /dev/null +++ b/backuppcd-notify.h @@ -0,0 +1,6 @@ +#ifndef _BACKUPPCD_NOTIFY_H +#define _BACKUPPCD_NOTIFY_H 1 + +void backuppc_notify(const char *host, const int port, const char *overridehostname); + +#endif diff --git a/backuppcd-passwd.c b/backuppcd-passwd.c new file mode 100644 index 0000000..5573840 --- /dev/null +++ b/backuppcd-passwd.c @@ -0,0 +1,48 @@ +#include "compat.h" +#include "sha1.h" + +int main(int argc, char **argv) { + char *plaintext; + char *fgets_ret; + int fail_cnt = 0; + + if (argc == 1) { + plaintext = malloc(1024); + if (!plaintext) { + perror("malloc"); + return(EXIT_FAILURE); + } + + plaintext[0] = '\0'; + + while (plaintext[0] == '\0' && fail_cnt < 3) { + printf("Password: "); + fflush(stdout); + + fgets_ret = fgets(plaintext, 1024, stdin); + if (!fgets_ret) { + perror("fgets"); + return(EXIT_FAILURE); + } + + if (plaintext[strlen(plaintext) - 1] == '\n') { + plaintext[strlen(plaintext) - 1] = '\0'; + } + + fail_cnt++; + } + } else if (argc > 1) { + plaintext = argv[1]; + } else { + return(EXIT_FAILURE); + } + + if (plaintext[0] == '\0') { + printf("Invalid password specified, aborting.\n"); + exit(EXIT_FAILURE); + } + + printf("%s\n", SHA1sum(plaintext)); + + return(EXIT_SUCCESS); +} diff --git a/backuppcd-tar.c b/backuppcd-tar.c new file mode 100644 index 0000000..9f9f55f --- /dev/null +++ b/backuppcd-tar.c @@ -0,0 +1,895 @@ +#include "compat.h" +#include "backuppcd.h" +#include "backuppcd-common.h" +#include "net.h" + +typedef enum { + BPC_CDT_END, + BPC_CDT_UINT8, + BPC_CDT_UINT16, + BPC_CDT_UINT32, + BPC_CDT_UINT64, + BPC_CDT_BYTEARRAY, + BPC_CDT_STRING, + BPC_CDT_STRING_PTR, +} backuppc_clntdt_t; + +#ifndef MSG_WAITALL +#define MSG_WAITALL 0 +#endif + +#ifndef BPC_MAXPATH_LEN +#define BPC_MAXPATH_LEN 4096 +#endif + +/* + * Example BackupPCd client with USTAR output. + */ + +int backuppcd_client(const char *host, const int port, const char *username, const char *password, const char *root); + +int main(int argc, char **argv) { + char *host, *rootpath, *username, *password; + int port; + int cmd_ret = -1; + + if (argc < 3) { + fprintf(stderr, "Usage: backuppcd-tar -xOf hostname:/path [... ignored...]\n"); + return(EXIT_FAILURE); + } + + password = getenv("PASSWD"); + + if (!password) { + fprintf(stderr, "Must supply password in the environment variable \"PASSWD\"\n"); + return(EXIT_FAILURE); + } + + host = strdup(argv[2]); + rootpath = strchr(host, ':'); + if (rootpath) { + *rootpath = '\0'; + rootpath++; + } else { + rootpath = "/"; + } + + port = 874; + username = "backuppc-tar"; + + cmd_ret = backuppcd_client(host, port, username, password, rootpath); + + if (cmd_ret < 0) { + return(EXIT_FAILURE); + } + + return(EXIT_SUCCESS); +} + + +int backuppcd_client_read(const int sockid, ...) { + backuppc_clntdt_t typeid; + va_list ap; + uint8_t *u8v; + uint16_t *u16v; + uint32_t *u32v; + uint64_t *u64v; + char *cpv, **cppv; + void *vpv = NULL, *vpv_s; + size_t vpv_len; + ssize_t read_ret; + + va_start(ap, sockid); + while (1) { + typeid = va_arg(ap, backuppc_clntdt_t); + + if (typeid == BPC_CDT_END) { + break; + } + + switch (typeid) { + case BPC_CDT_UINT8: + u8v = va_arg(ap, uint8_t *); + vpv_len = sizeof(*u8v); + vpv = u8v; + break; + case BPC_CDT_UINT16: + u16v = va_arg(ap, uint16_t *); + vpv_len = sizeof(*u16v); + vpv = u16v; + break; + case BPC_CDT_UINT32: + u32v = va_arg(ap, uint32_t *); + vpv_len = sizeof(*u32v); + vpv = u32v; + break; + case BPC_CDT_UINT64: + u64v = va_arg(ap, uint64_t *); + vpv_len = sizeof(*u64v); + vpv = u64v; + break; + case BPC_CDT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_CDT_STRING: + vpv_len = va_arg(ap, size_t); + vpv_len--; + cpv = va_arg(ap, char *); + cpv[vpv_len] = '\0'; + vpv = cpv; + break; + case BPC_CDT_STRING_PTR: + vpv_len = va_arg(ap, size_t); + cppv = va_arg(ap, char **); + if (*cppv == NULL) { + cpv = *cppv = malloc(vpv_len + 1); + cpv[vpv_len] = '\0'; + } else { + cpv = *cppv; + } + vpv = cpv; + break; + default: + return(0); + } + + vpv_s = vpv; + while (vpv_len) { + read_ret = recv(sockid, vpv, vpv_len, MSG_WAITALL); + + if (read_ret <= 0) { + return(0); + } + + vpv_len -= read_ret; + vpv += read_ret; + } + vpv = vpv_s; + + switch (typeid) { + case BPC_CDT_UINT16: + u16v = vpv; + *u16v = ntohs(*u16v); + break; + case BPC_CDT_UINT32: + u32v = vpv; + *u32v = ntohl(*u32v); + break; + case BPC_CDT_UINT64: + u64v = vpv; + *u64v = ntohll(*u64v); + break; + default: + break; + } + } + va_end(ap); + + return(1); +} + +int backuppcd_client_write(const int sockid, ...) { + backuppc_clntdt_t typeid; + va_list ap; + uint8_t u8v; + uint16_t u16v; + uint32_t u32v; + uint64_t u64v; + void *vpv; + char *cpv; + size_t vpv_len; + ssize_t write_ret; + + va_start(ap, sockid); + while (1) { + typeid = va_arg(ap, backuppc_clntdt_t); + + if (typeid == BPC_CDT_END) { + break; + } + + switch (typeid) { + case BPC_CDT_UINT8: + u8v = va_arg(ap, int); + vpv_len = sizeof(u8v); + vpv = &u8v; + break; + case BPC_CDT_UINT16: + u16v = va_arg(ap, int); + u16v = htons(u16v); + vpv_len = sizeof(u16v); + vpv = &u16v; + break; + case BPC_CDT_UINT32: + u32v = va_arg(ap, uint32_t); + u32v = htonl(u32v); + vpv_len = sizeof(u32v); + vpv = &u32v; + break; + case BPC_CDT_UINT64: + u64v = va_arg(ap, uint64_t); + u64v = htonll(u64v); + vpv_len = sizeof(u64v); + vpv = &u64v; + break; + case BPC_CDT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_CDT_STRING: + cpv = va_arg(ap, char *); + vpv_len = strlen(cpv); + vpv = cpv; + break; + case BPC_CDT_STRING_PTR: + default: + return(0); + } + + while (vpv_len) { + write_ret = send(sockid, vpv, vpv_len, 0); + + if (write_ret < 0) { + return(0); + } + + vpv_len -= write_ret; + vpv += write_ret; + } + } + va_end(ap); + + return(1); +} + + + +int backuppcd_client_auth(const int sockid, const char *username, const char *password) { + uint8_t cmd_reply; + uint8_t status; + + if (!backuppcd_client_write(sockid, + BPC_CDT_UINT8, (uint8_t) BPC_CMD_AUTH, + BPC_CDT_UINT16, (uint16_t) strlen(username), + BPC_CDT_UINT16, (uint16_t) strlen(password), + BPC_CDT_STRING, username, + BPC_CDT_STRING, password, + BPC_CDT_END)) { + return(0); + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &cmd_reply, + BPC_CDT_UINT8, (uint8_t *) &status, + BPC_CDT_END)) { + return(0); + } + + if (cmd_reply != BPC_CMD_AUTH_REPLY) { + return(0); + } + + if (status != BPC_STATUS_OKAY) { + return(0); + } + + return(1); +} + +int backuppcd_client_target(const int sockid, const char *rootpath, const int opt_verbosity, const int opt_totals) { + backuppc_cmd_t sendcmd; + unsigned char pathbuf[8192], *outpathbuf = NULL, tarbuf[512], *shortname, *dirname; + unsigned char *buf = NULL; + uint32_t attr_sect_len, blocksize, pathnamelen, blocknum = 0; + uint64_t filesize, byteswritten = 0; + uint32_t bufsize = 0; + uint32_t attr_uid, attr_gid, attr_ctime, attr_mtime, attr_devmajor, attr_devminor; + uint32_t attrlen; + uint32_t tar_checksum; + uint32_t tarblocks = 0; + uint16_t attrid; + uint16_t attr_mode; + uint8_t filetype, cmd; + ssize_t write_ret; + size_t writelen, bytes_to_copy; + time_t totaltime, starttime; + mode_t modeval; + char *attr_linkdest, *attr_username, *attr_groupname, *attr_hrdlinkdest; + char type_string[][7] = {"dir", "file", "syml", "sock", "fifo", "blk", "chr", "hrdl"}; + int tar_type; + int i, x, skipfile; + + starttime = time(NULL); + + sendcmd = BPC_CMD_GET; + + if (!backuppcd_client_write(sockid, + BPC_CDT_UINT8, (uint8_t) sendcmd, + BPC_CDT_UINT8, (uint8_t) BPC_OPT_RECURSIVE, + BPC_CDT_UINT32, (uint32_t) 0, /* exclude section length */ + BPC_CDT_UINT32, (uint32_t) 0, /* include section length */ + BPC_CDT_UINT32, (uint32_t) strlen(rootpath), + BPC_CDT_STRING, (char *) rootpath, + /* Exclude section is 0 bytes (XXX) */ + /* Include section is 0 bytes (XXX) */ + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &cmd, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + /* + * If the server sends us a reply for something other than what we + * asked for, something went wrong, abort. + */ + if (cmd != (sendcmd | 0x80)) { + CHECKPOINT; + return(0); + } + + /* + * Process every file entry in the reply. + */ + while (1) { + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &filetype, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + for (i = 0; i < sizeof(tarbuf); i++) { + tarbuf[i] = 0; + } + + if (filetype == 0xff) { + break; + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_sect_len, + BPC_CDT_UINT64, (uint64_t *) &filesize, + BPC_CDT_UINT32, (uint32_t *) &blocksize, + BPC_CDT_UINT32, (uint32_t *) &pathnamelen, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + + if (pathnamelen >= sizeof(pathbuf)) { + SPOTVAR_I(pathnamelen); + CHECKPOINT; + return(0); + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_STRING, (size_t) (pathnamelen + 1), &pathbuf, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + attr_uid = 0; + attr_gid = 0; + attr_mode = 0; + attr_ctime = 0; + attr_mtime = 0; + attr_devmajor = 0; + attr_devminor = 0; + attr_username = NULL; + attr_groupname = NULL; + attr_linkdest = NULL; + attr_hrdlinkdest = NULL; + + /* + * Read the sent attributes. + * Currently this does not handle all attributes and any + * attribute that is not handled is not properly sunk, instead + * the data remains in the buffer to be mis-processed later. + * Fix this (XXX) + */ + if (attr_sect_len != 0) { + while (1) { + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT16, (uint16_t *) &attrid, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (attrid == 0xffff) { + break; + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attrlen, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + switch ((backuppc_attrid_t) attrid) { + case BPC_ATTRID_NOP: + if (attrlen != 0) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_MTIME: + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_mtime, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_CTIME: + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_ctime, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_UID: + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_uid, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_GID: + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_gid, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_ACL: + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT16, (uint16_t *) &attr_mode, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + break; + case BPC_ATTRID_USER: + if (attrlen > BPC_MAXPATH_LEN) { + CHECKPOINT; + return(0); + } + + if (attr_username) { + free(attr_username); + } + + attr_username = NULL; + + if (!backuppcd_client_read(sockid, + BPC_CDT_STRING_PTR, (size_t) attrlen, (char **) &attr_username, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_GROUP: + if (attrlen > BPC_MAXPATH_LEN) { + CHECKPOINT; + return(0); + } + + if (attr_groupname) { + free(attr_groupname); + } + + attr_groupname = NULL; + + if (!backuppcd_client_read(sockid, + BPC_CDT_STRING_PTR, (size_t) attrlen, (char **) &attr_groupname, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_SYMLINKDEST: + if (attrlen > BPC_MAXPATH_LEN) { + CHECKPOINT; + return(0); + } + + if (attr_linkdest) { + free(attr_linkdest); + } + + attr_linkdest = NULL; + + if (!backuppcd_client_read(sockid, + BPC_CDT_STRING_PTR, (size_t) attrlen, (char **) &attr_linkdest, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + case BPC_ATTRID_HRDLINKDEST: + if (attrlen > BPC_MAXPATH_LEN) { + CHECKPOINT; + return(0); + } + + if (attr_hrdlinkdest) { + free(attr_hrdlinkdest); + } + + attr_hrdlinkdest = NULL; + + if (!backuppcd_client_read(sockid, + BPC_CDT_STRING_PTR, (size_t) attrlen, (char **) &attr_hrdlinkdest, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + break; + } + } + } + + /* + * Split the filename into 2 parts, the directory name and + * the file name. USTAR allows us to fit longer file names + * if we do this. + */ + shortname = strrchr(pathbuf, '/'); + if (shortname) { + *shortname = '\0'; + shortname++; + dirname = pathbuf; + } else { + shortname = pathbuf; + dirname = ""; + } + + /* + * Do not attempt to fill the USTAR header with data that will + * not fit. If an overflow condition is found, mark the file + * to be skipped and print a warning. + */ + skipfile = 0; + if (strlen(shortname) >= 100 || strlen(dirname) >= 155) { + fprintf(stderr, "Skipping %s/%s, pathname too long.\n", dirname, shortname); + skipfile = 1; + } + if (filesize >= 0x200000000LLU) { + fprintf(stderr, "Skipping %s/%s, file too large.\n", dirname, shortname); + skipfile = 1; + } + + /* + * Determine the POSIX "mode" value from the ACL attrs. + */ + modeval = 0; + if (attr_mode) { + if ((attr_mode & BPC_ACL_XUSR) == BPC_ACL_XUSR) { + modeval |= S_IXUSR; + } + if ((attr_mode & BPC_ACL_WUSR) == BPC_ACL_WUSR) { + modeval |= S_IWUSR; + } + if ((attr_mode & BPC_ACL_RUSR) == BPC_ACL_RUSR) { + modeval |= S_IRUSR; + } +#ifndef _USE_WIN32_ + if ((attr_mode & BPC_ACL_XGRP) == BPC_ACL_XGRP) { + modeval |= S_IXGRP; + } + if ((attr_mode & BPC_ACL_WGRP) == BPC_ACL_WGRP) { + modeval |= S_IWGRP; + } + if ((attr_mode & BPC_ACL_RGRP) == BPC_ACL_RGRP) { + modeval |= S_IRGRP; + } + if ((attr_mode & BPC_ACL_XOTH) == BPC_ACL_XOTH) { + modeval |= S_IXOTH; + } + if ((attr_mode & BPC_ACL_WOTH) == BPC_ACL_WOTH) { + modeval |= S_IWOTH; + } + if ((attr_mode & BPC_ACL_ROTH) == BPC_ACL_ROTH) { + modeval |= S_IROTH; + } + if ((attr_mode & BPC_ACL_STCK) == BPC_ACL_STCK) { + modeval |= S_ISVTX; + } + if ((attr_mode & BPC_ACL_SGID) == BPC_ACL_SGID) { + modeval |= S_ISGID; + } + if ((attr_mode & BPC_ACL_SUID) == BPC_ACL_SUID) { + modeval |= S_ISUID; + } +#endif + } + + /* + * Determine the USTAR "type" flag from the file type, and + * continue adding bits to the POSIX "mode" value. + */ + tar_type = 0; + if (filetype == BPC_FILE_REG) { + modeval |= S_IFREG; + tar_type = 0; + } +#ifndef _USE_WIN32_ + if (filetype == BPC_FILE_SYMLINK) { + modeval |= S_IFLNK; + tar_type = 1; + } + if (filetype == BPC_FILE_SOCKET) { + modeval |= S_IFSOCK; + tar_type = 2; /* ??? */ + } +#endif + if (filetype == BPC_FILE_DIR) { + modeval |= S_IFDIR; + tar_type = 5; + } + if (filetype == BPC_FILE_BDEV) { + modeval |= S_IFBLK; + tar_type = 4; + } + if (filetype == BPC_FILE_CDEV) { + modeval |= S_IFCHR; + tar_type = 3; + } + if (filetype == BPC_FILE_FIFO) { + modeval |= S_IFIFO; + tar_type = 6; + } + + /* + * Only send a header for this file if we intend to send the + * data for it. + */ + if (!skipfile) { + /* + * Generate the USTAR header in the buffer. + */ + memcpy(tarbuf, shortname, strlen(shortname)); + sprintf(tarbuf + 100, "%07o", modeval); + sprintf(tarbuf + 108, "%07o", attr_uid); + sprintf(tarbuf + 116, "%07o", attr_gid); + sprintf(tarbuf + 124, "%011o", (unsigned int) filesize); + sprintf(tarbuf + 136, "%011o", attr_mtime); + sprintf(tarbuf + 148, " "); + sprintf(tarbuf + 156, "%i", tar_type); + if (filetype == BPC_FILE_SYMLINK) { + sprintf(tarbuf + 157, attr_linkdest); + } + sprintf(tarbuf + 257, "ustar"); + sprintf(tarbuf + 263, " "); + if (attr_username) { + sprintf(tarbuf + 265, "%s", attr_username); + } + if (attr_groupname) { + sprintf(tarbuf + 297, "%s", attr_groupname); + } + if (attr_devmajor) { + sprintf(tarbuf + 329, "%07o", attr_devmajor); + } + if (attr_devminor) { + sprintf(tarbuf + 337, "%07o", attr_devminor); + } + sprintf(tarbuf + 345, "%s", dirname); + + /* Calculate checksum. */ + tar_checksum = 0; + for (i = 0; i < sizeof(tarbuf); i++) { + tar_checksum += tarbuf[i]; + } + sprintf(tarbuf + 148, "%06o", tar_checksum); + + write_ret = write(STDOUT_FILENO, tarbuf, sizeof(tarbuf)); + if (write_ret != sizeof(tarbuf)) { + CHECKPOINT; + return(0); + } + + /* + * Calculate the number of blocks this file will need + * including the 1-block header. + */ + tarblocks += 1 + ((filesize + sizeof(tarbuf) - 1) / sizeof(tarbuf)); + } + + switch (opt_verbosity) { + case 0: + break; + case 1: + fprintf(stderr, ".%s/%s\n", dirname, shortname); + break; + case 2: + fprintf(stderr, "[%4s] %04o %6lu %6lu %10llu %12lu %s/%s", + type_string[filetype], + (unsigned int) attr_mode, + (unsigned long) attr_uid, + (unsigned long) attr_gid, + (unsigned long long) filesize, + (unsigned long) attr_mtime, + dirname, + shortname); + if (filetype == BPC_FILE_SYMLINK) { + fprintf(stderr, " -> %s", attr_linkdest); + } + fprintf(stderr, "\n"); + break; + } + + outpathbuf = pathbuf + 1; + + byteswritten = 0; + + /* + * Ensure the buffer is large enough to hold all the data. + * If the buffer starts changing a lot between files, we + * should make this grow-only. It's fine for now. + */ + if (bufsize != blocksize) { + if (buf) { + free(buf); + } + + bufsize = blocksize; + + buf = malloc(bufsize); + + if (!buf) { + CHECKPOINT; + return(0); + } + } + + /* + * Read the file data from the server. We must do this even + * if we are not planning on sending it in USTAR format. + * The data comes in "blocksize" sized blocks and may be + * larger than the actual file. + */ + while (1) { + if (!backuppcd_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &blocknum, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (blocknum == 0xffffffff) { + break; + } + + if (!backuppcd_client_read(sockid, + BPC_CDT_BYTEARRAY, (size_t) blocksize, (void *) buf, + BPC_CDT_END)) { + + CHECKPOINT; + return(0); + } + + /* + * Determine the amount of data in this block that we + * should write. Currently this fails to deal with + * sparse files and assumes that an entire file is + * with all blocks in order. This will need to change. + * (XXX) + */ + if ((byteswritten + blocksize) > filesize) { + if (filesize > byteswritten) { + writelen = filesize - byteswritten; + } else { + writelen = 0; + } + } else { + writelen = blocksize; + } + + if (!skipfile) { + /* + * Send the file data if there is any. + */ + if (writelen > 0) { + x = 0; + while (x < writelen) { + write_ret = write(STDOUT_FILENO, buf + x, writelen - x); + + if (write_ret <= 0) { + CHECKPOINT; + return(0); + } + + x += write_ret; + } + } + } + + byteswritten += blocksize; + } + + if (!skipfile) { + /* + * Round the file to 512-byte blocks. + */ + bytes_to_copy = sizeof(tarbuf) - (filesize % sizeof(tarbuf)); + if (bytes_to_copy != sizeof(tarbuf)) { + for (i = 0; i < bytes_to_copy; i++) { + tarbuf[i] = 0; + } + write_ret = write(STDOUT_FILENO, tarbuf, bytes_to_copy); + if (write_ret != bytes_to_copy) { + CHECKPOINT; + return(0); + } + } + } + + /* Clean up any allocated memory, if needed. */ + if (attr_linkdest) { + free(attr_linkdest); + } + if (attr_username) { + free(attr_username); + } + if (attr_groupname) { + free(attr_groupname); + } + if (attr_hrdlinkdest) { + free(attr_hrdlinkdest); + } + } + + /* + * USTAR end of archive is two empty blocks. + */ + write(STDOUT_FILENO, tarbuf, sizeof(tarbuf)); + write(STDOUT_FILENO, tarbuf, sizeof(tarbuf)); + tarblocks += 2; + + if (opt_totals) { + totaltime = time(NULL) - starttime; + if (totaltime == 0) { + totaltime = 1; + } + + fprintf(stderr, "Total bytes written: %lu (%luKiB, %fKiB/s)\n", (unsigned long) (tarblocks * sizeof(tarbuf)), (unsigned long) (tarblocks * sizeof(tarbuf) / 1024), (((double) tarblocks * sizeof(tarbuf)) / 1024.0) / ((double) totaltime)); + } + + CHECKPOINT; + return(1); +} + +int backuppcd_client(const char *host, const int port, const char *username, const char *password, const char *rootpath) { + int sockid; + + sockid = net_connect_tcp(host, port); + + if (sockid < 0) { + return(-1); + } + + if (!backuppcd_client_auth(sockid, username, password)) { + return(-1); + } + + if (!backuppcd_client_target(sockid, rootpath, 1, 1)) { + return(-1); + } + + return(0); +} diff --git a/backuppcd.c b/backuppcd.c new file mode 100644 index 0000000..6fcb3b3 --- /dev/null +++ b/backuppcd.c @@ -0,0 +1,3879 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#include "compat.h" +#include "backuppcd.h" +#include "backuppcd-common.h" +#include "backuppcd-auth.h" +#include "backuppcd-notify.h" +#include "net.h" +#include "sha1.h" +#include "md4.h" +#include "md5.h" + +#define DAEMON_RET_SUCCESS 0 +#define DAEMON_RET_FAILURE 1 + +#define BPC_PRIO_MIN 0 +#define BPC_PRIO_NORM 1 +#define BPC_PRIO_MAX 2 + +#define LOOP_RUN 0 +#define LOOP_STOP 1 +#define LOOP_DONE 2 + +#ifndef SKIPSTARTFILE +#define SKIPSTARTFILE SYSCONFDIR "/backuppcd-disable" +#endif + +#ifndef O_BINARY +#define O_BINARY 0 +#endif +#ifndef O_LARGEFILE +#define O_LARGEFILE 0 +#endif +#ifndef SIGPIPE +#define SIGPIPE 13 +#endif + +#ifndef BPC_MAXUSERNAME_LEN +#define BPC_MAXUSERNAME_LEN 128 +#endif +#ifndef BPC_MAXPASSWORD_LEN +#define BPC_MAXPASSWORD_LEN 256 +#endif +#ifndef BPC_MAXPATH_LEN +#define BPC_MAXPATH_LEN 4096 +#endif +#ifndef BPC_MAXOUTBUF_LEN +#define BPC_MAXOUTBUF_LEN 819200 +#endif +#ifndef BPC_OUTBUF_LEN +#define BPC_OUTBUF_LEN 32768 +#endif +#ifndef BPC_BUF_LEN +#define BPC_BUF_LEN 32768 +#endif +#ifndef BPC_UPDATE_INTERVAL +#define BPC_UPDATE_INTERVAL 300 +#endif + +/* + * Default master password: This value will never match any SHA1 hash. + * + */ +#ifndef BPC_CONF_MASTER_PASSWORD +#define BPC_CONF_MASTER_PASSWORD "7505d64a54e061b7acd54ccd58b49dc43500b63x" +#endif + +/* + * This global variable is used to coordinate the shutdown of the main work + * loop (backuppc_loop()). + */ +static int WorkLoopStatus = LOOP_RUN; + +/* + * These variables are global because the configuration is done by a seperate + * function. + */ +static int backuppc_port = BPC_TCP_PORT; +static uint32_t backuppc_writeblock_size = 32000; +static char *backuppc_updateurl = BPC_CONF_UPDATEURL; +static char *backuppc_binfile = NULL; +static char *backuppc_notifyserv = BPC_CONF_NOTIFYSERV; +static int backuppc_notifyport = BPC_TCP_NOTIFYPORT; + +#ifdef _USE_WIN32_ +/* + * Win32 service stuff. + */ +static SC_HANDLE manager = NULL; +static SC_HANDLE service = NULL; +static SERVICE_STATUS backuppcServiceStat; +static SERVICE_STATUS_HANDLE backuppcServiceStat_handle = (SERVICE_STATUS_HANDLE) NULL; +static char svcName[] = "BackupPC"; +#endif + +/* + * These are symbolic names to use to mark when a message datum has been sent. + */ +typedef enum { + BPC_SM_NONE, + BPC_SM_HEADER, + BPC_SM_PKT_HEADER, + BPC_SM_CLEANUP, + BPC_SM_PATHNAME, + BPC_SM_DATA_CLEANUP, + BPC_SM_AUTHSTATUS, + _BPC_SM_SIZE /* Must be the last item*/ +} backuppc_send_mark_t; + +/* + * These are symbolic names to use to mark when a message datum has been + * recieved. + */ +typedef enum { + BPC_RM_NONE, + BPC_RM_HEADER, + BPC_RM_PKT_HEADER, + BPC_RM_PATHNAME, + BPC_RM_AUTHDATA, + _BPC_RM_SIZE /* Must be the last item. */ +} backuppc_recv_mark_t; + +/* + * These define the different data types that backuppc_readvalues() and + * backuppc_writevalues() understand. + */ +typedef enum { + BPC_DT_END, + BPC_DT_UINT8, + BPC_DT_UINT16, + BPC_DT_UINT32, + BPC_DT_UINT64, + BPC_DT_BYTEARRAY, + BPC_DT_BYTEARRAY_PTR, + BPC_DT_STRING, + BPC_DT_STRING_PTR, +} backuppc_datatypes_t; + +/* + * Every client that connects is given a node of this type to handle its + * buffering. + * + * The (void *) process_handle entry is for the backuppc_process_client() + * call to store data in. It should be filled out by + * backuppc_process_client_init() and cleaned by + * backuppc_process_client_fini(). + */ +struct backuppc_client_info; +struct backuppc_client_info { + struct in_addr addr; + unsigned char *buf; + unsigned char *buf_s; + unsigned long bufsize; + unsigned long bufsize_s; + unsigned long bufused; + unsigned char *outbuf; + unsigned char *outbuf_s; + unsigned long outbufsize; + unsigned long outbufsize_s; + unsigned long outbufused; + void *process_handle; + int outdata_waiting; + int tx_error_count; + int rx_error_count; + int invalid_data; + int fd; + backuppc_privs_t privs; + struct backuppc_client_info *_next; +}; + +/* + * backuppc_process_client()'s private data storage, maintains things like + * state of the current command and various other items across calls. + */ +struct backuppc_client_prochandle { + struct backuppc_dirent *dent; + backuppc_cmd_t cmd; + unsigned char *tmpbuf; + uint16_t username_len; + uint16_t password_len; + uint32_t pathname_len; + uint32_t excl_sect_len; + uint32_t incl_sect_len; + uint32_t block_num; + uint8_t options; + size_t tmpbufsize; + size_t tmpbufused; + size_t bytes_written; + size_t attrlen; + char *username; + char *password; + char *pathname; + char *data; + char attrdata[4096]; + void *dh[256]; + int dhidx; + int sent_sect[_BPC_SM_SIZE]; + int recv_sect[_BPC_RM_SIZE]; + int wv_idx; + int rv_idx; +}; + +/* + * Structure pointed to by the backuppc_readdir() + * + * Holds information about the file, as well as a file descriptor if opened by + * backuppc_openfile(). + */ +struct backuppc_dirent { + backuppc_filetype_t type; + unsigned char md5[16]; + const char *name; + char fullpathname[BPC_MAXPATH_LEN]; + char *symlinkdest; + char *hrdlinkdest; + off_t size; + dev_t dev; + mode_t mode; + uid_t uid; + gid_t gid; + uint64_t blocks; + uint32_t blksize; + dev_t rdev; + time_t mtime; + time_t ctime; + int md5_set; + int issparse; + int fd; +}; + +struct backuppc_inode_list; +struct backuppc_inode_list { + ino_t inode_num; + char *fullpathname; + struct backuppc_inode_list *_next; +}; + +/* + * Private structure handle used by backuppc_opendir() and backuppc_closedir() + */ +typedef struct backuppc_dirhandle { + struct backuppc_inode_list *ilist[4097]; /* This needs to be moved, otherwise hardlinks are only checked from the same dir.. XXX */ + struct backuppc_dirent ret; + char *pat_exclude[8192]; + char *pat_include[8192]; + char *pathname; + DIR *handle; + int lastdrivecheck; + int isfile; +} BPC_DIR; + +static void backuppc_setpriority(int prio) { +#ifdef _USE_WIN32_ + DWORD prio_class; + + switch (prio) { + case BPC_PRIO_MAX: + prio_class = HIGH_PRIORITY_CLASS; + break; + case BPC_PRIO_NORM: + prio_class = NORMAL_PRIORITY_CLASS; + break; + case BPC_PRIO_MIN: + default: + prio_class = BELOW_NORMAL_PRIORITY_CLASS; + break; + } + + SetPriorityClass(GetCurrentProcess(), prio_class); +#else + int prio_val; + + switch (prio) { + case BPC_PRIO_MAX: + prio_val = -15; + break; + case BPC_PRIO_NORM: + prio_val = 0; + break; + case BPC_PRIO_MIN: + default: + prio_val = 10; + break; + } + +#ifdef HAVE_SETPRIORITY + setpriority(PRIO_PROCESS, 0, prio_val); +#else +#warning NO WAY TO HANDLE PRIORITY +#endif +#endif + return; +} + + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function compiles to a no-op on platforms that already have a single + * unified namespace. + * + * On Win32 this function changes pathnames containing a drive letter style + * pathname to a more sane name including the leading slash. + * + */ +static void backuppc_pathmangle(char *pathname) { +#ifdef _USE_WIN32_ + char drive_letter; + + if (strlen(pathname) < 2) { + return; + } + + if (pathname[0] == '/' && isalpha(pathname[1])) { + return; + } + + if (pathname[1] != ':' || !isalpha(pathname[0])) { + return; + } + + drive_letter = pathname[0]; + pathname[0] = '/'; + pathname[1] = drive_letter; + +#endif + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathunmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to unmangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function compiles to a no-op on platforms that already have a single + * unified namespace. + * + * On Win32 this function changes pathnames containing a sane pathname to + * a pathname that contains a drive letter and can be used to open or + * otherwise access the file. + * + */ +static void backuppc_pathunmangle(char *pathname) { +#ifdef _USE_WIN32_ + char drive_letter; + + if (strlen(pathname) < 2) { + return; + } + + if (pathname[1] == ':' && isalpha(pathname[0])) { + return; + } + + if (pathname[0] != '/' || !isalpha(pathname[1])) { + return; + } + + drive_letter = pathname[1]; + pathname[0] = drive_letter; + pathname[1] = ':'; + +#endif + return; +} + +/* + * SYNOPSIS: + * static BPC_DIR *backuppc_opendir( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to the directory to open + * + * RETURN VALUE: + * This function returns a pointer to a handle that can be used with + * backuppc_readdir() and backuppc_closedir(). It returns NULL on + * error. + * + * NOTES: + * If you backuppc_opendir() a file, you get a handle that when you call + * backuppc_readdir() gives you exactly one entry, the pathname specified. + * Thus you should not assume that the result of backuppc_readdir() gives + * a child-node in the directory heirarchy of the pathname specified when + * this function is called. the (struct backuppc_dirent).fullpathname + * value should be used instead to get the full path to the relevant node. + * + */ +static BPC_DIR *backuppc_opendir(char *pathname) { + BPC_DIR *dh; + struct stat stbuf; + FILE *directive_fp; + char dir_directive_file[BPC_MAXPATH_LEN]; + char buf[1024]; + int excnt = 0, incnt = 0; + int stat_ret; + int i; + + if (pathname[0] != '/') { + return(NULL); + } + + dh = malloc(sizeof(*dh)); + + if (!dh) { + return(NULL); + } + + dh->pat_exclude[0] = NULL; + dh->pat_include[0] = NULL; + dh->isfile = 0; + + for (i = 0; i < (sizeof(dh->ilist) / sizeof(dh->ilist[0])); i++) { + dh->ilist[i] = NULL; + } + +#ifdef _USE_WIN32_ + if (strlen(pathname) < 2) { + dh->pathname = strdup("/"); + dh->handle = NULL; + dh->lastdrivecheck = 0; + return(dh); + } +#endif + + backuppc_pathunmangle(pathname); + + dh->handle = opendir(pathname); + + snprintf(dir_directive_file, sizeof(dir_directive_file), "%s/%s", pathname, ".bpc"); + + backuppc_pathmangle(pathname); + + if (!dh->handle) { + backuppc_pathunmangle(pathname); +#ifdef HAVE_LSTAT + stat_ret = lstat(pathname, &stbuf); +#else + stat_ret = stat(pathname, &stbuf); +#endif + backuppc_pathmangle(pathname); + + if (stat_ret < 0) { + free(dh); + dh = NULL; + return(dh); + } + + if (S_ISDIR(stbuf.st_mode)) { + free(dh); + dh = NULL; + return(dh); + } + + dh->isfile = 1; + } + + dh->lastdrivecheck = 0; + dh->pathname = strdup(pathname); + + dh->ret.symlinkdest = NULL; + dh->ret.hrdlinkdest = NULL; + + directive_fp = fopen(dir_directive_file, "r"); + if (directive_fp) { + while (1) { + fgets(buf, sizeof(buf), directive_fp); + + if (feof(directive_fp)) { + break; + } + + if (strlen(buf) < 2) { + continue; + } + + if (buf[strlen(buf) - 1] < ' ') { + buf[strlen(buf) - 1] = '\0'; + } + + switch (buf[0]) { + case '+': + dh->pat_include[incnt] = strdup(buf + 1); + incnt++; + case '-': + dh->pat_exclude[excnt] = strdup(buf + 1); + excnt++; + default: + break; + } + } + } + + return(dh); +} + +/* + * SYNOPSIS: + * static struct backuppc_dirent *backuppc_readdir( + * BPC_DIR *dh + * ); + * + * ARGUMENTS: + * BPC_DIR *dh Directory stream handle, from backuppc_opendir() + * + * RETURN VALUE: + * This function returns a pointer to a (struct backuppc_dirent). Every + * call will return the same pointer for the specified directory handle. + * This function returns NULL when there are no more nodes that can be + * processed available in the stream or an error occurs. + * + * NOTES: + * Under Win32, this function presents the children of "/" as the letters + * of all drives that are not "removable", "remote", or "cdrom". + * + * The size for non-regular file nodes will always be zero, regardless of + * how many blocks they actually take up on the disk. + * + */ +static struct backuppc_dirent *backuppc_readdir(BPC_DIR *dh) { + struct backuppc_inode_list *cur_inode; + struct dirent *dent; + struct stat stbuf; + size_t pathnamelen; +#ifdef _USE_WIN32_ + DWORD drives; + UINT drive_type; + char drive_letter; + char drive_letter_str[32]; + int i, drive_exists; +#endif + int stat_ret, readlink_ret; + int pat_incidx, pat_exlidx; + int hash_idx; + int exclude_file; + + if (!dh) { + return(NULL); + } + + if (!dh->handle && !dh->isfile) { +#ifdef _USE_WIN32_ + /* On Win32, dh->handle being NULL indicates the fake root + directory we are to construct. */ + drives = GetLogicalDrives(); + + for (i = dh->lastdrivecheck; i < (sizeof(drives) * 8); i++) { + drive_exists = drives & (1 << i); + + if (drive_exists) { + drive_letter = 'A' + i; + + /* The trailing slashes are required here, + otherwise Windows thinks we mean the + current directory on that drive instead + of the root directory. */ + sprintf(drive_letter_str, "%c:\\", drive_letter); + snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "/%c/", drive_letter); + + drive_type = GetDriveType(drive_letter_str); + + if (drive_type == DRIVE_REMOVABLE || drive_type == DRIVE_REMOTE || drive_type == DRIVE_CDROM) { + continue; + } + + dh->lastdrivecheck = i + 1; + drive_letter_str[1] = '\0'; + dh->ret.name = strdup(drive_letter_str); + dh->ret.type = BPC_FILE_DIR; + dh->ret.size = 0; +// dh->ret.inode = ((0xf << ((sizeof(dh->ret.inode) * 8) - 4)) | ((1 << ((sizeof(dh->ret.inode) * 8) - 1)) - 1)) - i; + dh->ret.md5_set = 0; + dh->ret.fd = -1; + dh->ret.dev = 0; + dh->ret.rdev = 0; + dh->ret.mode = 0; + dh->ret.uid = 0; + dh->ret.gid = 0; + dh->ret.blocks = 0; + dh->ret.mtime = 0; + dh->ret.ctime = 0; + return(&dh->ret); + } + } +#endif + return(NULL); + } + + pathnamelen = strlen(dh->pathname); + + /* + * A zero-length pathname never makes sense, and it will break some + * calculations below. + */ + if (pathnamelen < 1) { + return(NULL); + } + + while (1) { + if (!dh->isfile) { + dent = readdir(dh->handle); + + if (!dent) { + break; + } + + if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) { + continue; + } + + if (dh->pathname[pathnamelen - 1] == '/') { + snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s%s", dh->pathname, dent->d_name); + } else { + snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s/%s", dh->pathname, dent->d_name); + } + } else { + if (dh->isfile == 2) { + break; + } + + snprintf(dh->ret.fullpathname, sizeof(dh->ret.fullpathname), "%s", dh->pathname); + + dh->isfile = 2; + } + + backuppc_pathunmangle(dh->ret.fullpathname); + +#ifdef HAVE_LSTAT + stat_ret = lstat(dh->ret.fullpathname, &stbuf); +#else + stat_ret = stat(dh->ret.fullpathname, &stbuf); +#endif + + backuppc_pathmangle(dh->ret.fullpathname); + + if (stat_ret < 0) { + continue; + } + + dh->ret.name = strrchr(dh->ret.fullpathname, '/'); + if (!dh->ret.name) { + continue; + } + dh->ret.name++; + + dh->ret.dev = stbuf.st_dev; + dh->ret.rdev = stbuf.st_rdev; + dh->ret.mode = stbuf.st_mode; + dh->ret.uid = stbuf.st_uid; + dh->ret.gid = stbuf.st_gid; +#ifdef _USE_WIN32_ + dh->ret.blksize = 1024; + dh->ret.blocks = (stbuf.st_size + dh->ret.blksize - 1) / dh->ret.blksize; +#else + dh->ret.blksize = stbuf.st_blksize; + dh->ret.blocks = stbuf.st_blocks; +#endif + dh->ret.mtime = stbuf.st_mtime; + dh->ret.ctime = stbuf.st_ctime; + dh->ret.md5_set = 0; + dh->ret.fd = -1; + + /* + * Process exclusions stored in the BPC_DIR structure. We + * exclude anything matching a "pat_exclude" rule, unless it + * also matches a "pat_include" rule. + */ + exclude_file = 0; + for (pat_exlidx = 0; pat_exlidx < (sizeof(dh->pat_exclude) / sizeof(dh->pat_exclude[0])); pat_exlidx++) { + if (!dh->pat_exclude[pat_exlidx]) { + break; + } + + if (fnmatch(dh->pat_exclude[pat_exlidx], dh->ret.name, FNM_PERIOD) == 0) { + exclude_file = 1; + + for (pat_incidx = 0; pat_incidx < (sizeof(dh->pat_include) / sizeof(dh->pat_include[0])); pat_incidx++) { + if (!dh->pat_include[pat_incidx]) { + break; + } + if (fnmatch(dh->pat_include[pat_incidx], dh->ret.name, FNM_PERIOD) == 0) { + exclude_file = 0; + } + } + } + } + + /* + * Skip excluded files + */ + if (exclude_file) { + continue; + } + + switch (stbuf.st_mode & S_IFMT) { + case S_IFREG: + dh->ret.type = BPC_FILE_REG; + break; +#ifdef S_IFLNK + case S_IFLNK: + dh->ret.type = BPC_FILE_SYMLINK; +#ifdef HAVE_READLINK + if (!dh->ret.symlinkdest) { + dh->ret.symlinkdest = malloc(BPC_MAXPATH_LEN); + } + readlink_ret = readlink(dh->ret.fullpathname, dh->ret.symlinkdest, BPC_MAXPATH_LEN); + if (readlink_ret > 0 && readlink_ret < BPC_MAXPATH_LEN) { + dh->ret.symlinkdest[readlink_ret] = '\0'; + } else { + dh->ret.symlinkdest[0] = '\0'; + } +#endif + break; +#endif + case S_IFCHR: + dh->ret.type = BPC_FILE_CDEV; + break; + case S_IFBLK: + dh->ret.type = BPC_FILE_BDEV; + break; + case S_IFDIR: + dh->ret.type = BPC_FILE_DIR; + break; + case S_IFIFO: + dh->ret.type = BPC_FILE_FIFO; + break; +#ifdef S_IFSOCK + case S_IFSOCK: + dh->ret.type = BPC_FILE_SOCKET; + break; +#endif + default: + dh->ret.type = BPC_FILE_UNKNOWN; + break; + } + + /* + * If a file has a link count greater than one, determine if + * we have seen it before, if not note that we've seen it now + * so we can look for it later. + */ + if (stbuf.st_nlink > 1 && dh->ret.type != BPC_FILE_DIR && dh->ret.type != BPC_FILE_UNKNOWN) { + hash_idx = stbuf.st_ino % (sizeof(dh->ilist) / sizeof(dh->ilist[0])); + for (cur_inode = dh->ilist[hash_idx]; cur_inode; cur_inode = cur_inode->_next) { + if (cur_inode->inode_num == stbuf.st_ino) { + dh->ret.type = BPC_FILE_HRDLINK; + dh->ret.hrdlinkdest = cur_inode->fullpathname; + break; + } + } + + if (dh->ret.type != BPC_FILE_HRDLINK) { + cur_inode = malloc(sizeof(*cur_inode)); + cur_inode->inode_num = stbuf.st_ino; + cur_inode->fullpathname = strdup(dh->ret.fullpathname); + cur_inode->_next = dh->ilist[hash_idx]; + dh->ilist[hash_idx] = cur_inode; + } + } + + + if (dh->ret.type == BPC_FILE_REG) { + dh->ret.size = stbuf.st_size; + } else { + dh->ret.size = 0; + } + + dh->ret.issparse = 0; + + return(&dh->ret); + } + + return(NULL); +} + +/* + * SYNOPSIS: + * static void backuppc_closedir( + * BPC_DIR *dh); + * ); + * + * ARGUMENTS: + * BPC_DIR *dh Directory stream handle, from backuppc_opendir() + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function closes an opened directory stream. It cleans up any + * resources related to that stream. The handle specified should not be + * used once this function has been called. + * + */ +static void backuppc_closedir(BPC_DIR *dh) { + struct backuppc_inode_list *cur_inode, *next_inode; + int hash_idx; + int pat_idx; + + if (!dh) { + return; + } + + if (dh->pathname) { + free(dh->pathname); + } + + if (dh->handle) { + closedir(dh->handle); + } + + if (dh->ret.symlinkdest) { + free(dh->ret.symlinkdest); + } + + for (pat_idx = 0; pat_idx < (sizeof(dh->pat_exclude) / sizeof(dh->pat_exclude[0])); pat_idx++) { + if (!dh->pat_exclude[pat_idx]) { + break; + } + + free(dh->pat_exclude[pat_idx]); + } + + for (pat_idx = 0; pat_idx < (sizeof(dh->pat_include) / sizeof(dh->pat_include[0])); pat_idx++) { + if (!dh->pat_include[pat_idx]) { + break; + } + + free(dh->pat_include[pat_idx]); + } + + for (hash_idx = 0; hash_idx < (sizeof(dh->ilist) / sizeof(dh->ilist[0])); hash_idx++) { + cur_inode = dh->ilist[hash_idx]; + while (cur_inode) { + if (cur_inode->fullpathname) { + free(cur_inode->fullpathname); + } + + next_inode = cur_inode->_next; + + free(cur_inode); + + cur_inode = next_inode; + } + } + + free(dh); + + return; +} + +/* + * SYNOPSIS: + * static int backuppc_openfile( + * struct backuppc_dirent *dent, + * int flags, + * mode_t mode + * ); + * + * ARGUMENTS: + * struct backuppc_dirent *dent Pointer to structure containing information + * about file to open. + * int flags Flags to open file with, should include one + * of O_RDONLY, O_RDWR, or O_WRONLY. + * mode_t mode Permissions to set on file if it is to be + * created. + * + * RETURN VALUE: + * This function returns the file descriptor associated with the open file + * on success, or -1 on failure. + * + * NOTES: + * This function sets the "fd" member of the structure pointed to by the + * "dent" parameter to the file descriptor. + * + * If the file "fd" member is already set to a positive value, that value + * is returned and the file is not opened nor is its state changed. + * + */ +static int backuppc_openfile(struct backuppc_dirent *dent, int flags, mode_t mode) { + char *pathname; + int fd; + + if (dent->type != BPC_FILE_REG) { + CHECKPOINT; + return(-1); + } + + if (dent->fd >= 0) { + CHECKPOINT; + return(dent->fd); + } + + pathname = dent->fullpathname; + + backuppc_pathunmangle(pathname); + + fd = open(pathname, flags | O_LARGEFILE | O_BINARY, mode); + + backuppc_pathmangle(pathname); + + if (fd < 0) { + CHECKPOINT; + return(-1); + } + + dent->fd = fd; + + return(fd); +} + +/* + * SYNOPSIS: + * static int backuppc_closefile( + * struct backuppc_dirent *dent + * ); + * + * ARGUMENTS: + * struct backuppc_dirent *dent Pointer to structure containing information + * about file to close. + * + * RETURN VALUE: + * Zero is returned on success, or -1 if an error occurs. It is not + * considered an error to close an already closed file. + * + * NOTES: + * + */ +static int backuppc_closefile(struct backuppc_dirent *dent) { + int fd; + + if (dent->fd < 0) { + return(0); + } + + fd = dent->fd; + dent->fd = -1; + + return(close(fd)); +} + +/* + * SYNOPSIS: + * static void backuppc_get_attr(void); + * + * ARGUMENTS: + * (none) + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function needs to be written + * + */ +static ssize_t backuppc_get_attr(struct backuppc_dirent *dent, char *outbuf, size_t outbuflen, uint8_t options) { + rsaref_MD4_CTX md4_ctx; + ld_MD5_CTX bpchash_ctx; + ld_MD5_CTX md5_ctx; + SHA1_CTX sha1_ctx; + uint64_t filepos = 0, preread_filepos; + uint32_t len, timeval, idval; + uint16_t modeval; + uint16_t id; + ssize_t read_ret; + char *buf = outbuf; + char filebuf[16384]; + unsigned char digest[20]; + char filesizestrbuf[21]; + uint32_t bpc_hashstop = 0; + int fd; + + if (dent->mtime > 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(timeval))) { + id = htons(BPC_ATTRID_MTIME); + len = htonl(sizeof(timeval)); + timeval = htonl(dent->mtime); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, &timeval, sizeof(timeval)); + buf += sizeof(timeval); + } + + if (dent->ctime > 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(timeval))) { + id = htons(BPC_ATTRID_CTIME); + len = htonl(sizeof(timeval)); + timeval = htonl(dent->ctime); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, &timeval, sizeof(timeval)); + buf += sizeof(timeval); + } + + /* BPC_ATTRID_USER */ + /* BPC_ATTRID_GROUP */ + + if (dent->uid >= 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(idval))) { + id = htons(BPC_ATTRID_UID); + len = htonl(sizeof(idval)); + idval = htonl(dent->uid); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, &idval, sizeof(idval)); + buf += sizeof(idval); + } + + if (dent->gid >= 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(idval))) { + id = htons(BPC_ATTRID_GID); + len = htonl(sizeof(idval)); + idval = htonl(dent->gid); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, &idval, sizeof(idval)); + buf += sizeof(idval); + } + + if (dent->mode != 0 && (outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + sizeof(modeval))) { + id = htons(BPC_ATTRID_ACL); + len = htonl(sizeof(modeval)); + + modeval = 0; + + if ((dent->mode & S_IRUSR) == S_IRUSR) { + modeval |= BPC_ACL_RUSR; + } + if ((dent->mode & S_IWUSR) == S_IWUSR) { + modeval |= BPC_ACL_WUSR; + } + if ((dent->mode & S_IXUSR) == S_IXUSR) { + modeval |= BPC_ACL_XUSR; + } +#ifndef _USE_WIN32_ + if ((dent->mode & S_IRGRP) == S_IRGRP) { + modeval |= BPC_ACL_RGRP; + } + if ((dent->mode & S_IWGRP) == S_IWGRP) { + modeval |= BPC_ACL_WGRP; + } + if ((dent->mode & S_IXGRP) == S_IXGRP) { + modeval |= BPC_ACL_XGRP; + } + if ((dent->mode & S_IROTH) == S_IROTH) { + modeval |= BPC_ACL_ROTH; + } + if ((dent->mode & S_IWOTH) == S_IWOTH) { + modeval |= BPC_ACL_WOTH; + } + if ((dent->mode & S_IXOTH) == S_IXOTH) { + modeval |= BPC_ACL_XOTH; + } + if ((dent->mode & S_ISVTX) == S_ISVTX) { + modeval |= BPC_ACL_STCK; + } + if ((dent->mode & S_ISGID) == S_ISGID) { + modeval |= BPC_ACL_SGID; + } + if ((dent->mode & S_ISUID) == S_ISUID) { + modeval |= BPC_ACL_SUID; + } +#endif + + modeval = htons(modeval); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, &modeval, sizeof(modeval)); + buf += sizeof(modeval); + } + + if (dent->type == BPC_FILE_SYMLINK && dent->symlinkdest) { + if ((outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + strlen(dent->symlinkdest))) { + id = htons(BPC_ATTRID_SYMLINKDEST); + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + len = htonl(strlen(dent->symlinkdest)); + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, dent->symlinkdest, strlen(dent->symlinkdest)); + buf += strlen(dent->symlinkdest); + } + } + + if (dent->type == BPC_FILE_HRDLINK && dent->hrdlinkdest) { + if ((outbuflen - (buf - outbuf)) >= (sizeof(id) + sizeof(len) + strlen(dent->hrdlinkdest))) { + id = htons(BPC_ATTRID_HRDLINKDEST); + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + len = htonl(strlen(dent->hrdlinkdest)); + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, dent->hrdlinkdest, strlen(dent->hrdlinkdest)); + buf += strlen(dent->hrdlinkdest); + } + } + + if (dent->type == BPC_FILE_REG && \ + ((options & BPC_OPT_MD4) == BPC_OPT_MD4 || \ + (options & BPC_OPT_MD5) == BPC_OPT_MD5 || \ + (options & BPC_OPT_SHA1) == BPC_OPT_SHA1 || \ + (options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH)) { + if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { + rsaref_MD4Init(&md4_ctx); + } + if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { + ld_MD5Init(&md5_ctx); + } + if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { + SHA1Init(&sha1_ctx); + } + if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { + /* + * The BPC hash is weird. It's a hash of the + * following: + * FILESIZE % (2^32 -1) (string) + * First 128KB of data + * Data between 1024KB - 128KB and 1024KB + * (less if required to prevent overlapping + * windows, last 128KB section moves + * backwards if file is short.) + */ + ld_MD5Init(&bpchash_ctx); + + snprintf(filesizestrbuf, sizeof(filesizestrbuf), "%llu", (long long unsigned) (dent->size % 0xffffffff)); + ld_MD5Update(&bpchash_ctx, filesizestrbuf, strlen(filesizestrbuf)); + + if (dent->size > 1048576) { + bpc_hashstop = 1048576; + } else { + bpc_hashstop = dent->size; + } + } + + fd = backuppc_openfile(dent, O_RDONLY, 0600); + + if (fd >= 0) { + while (1) { + read_ret = read(fd, filebuf, sizeof(filebuf)); + + if (read_ret <= 0) { + break; + } + + filepos += read_ret; + + if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { + rsaref_MD4Update(&md4_ctx, filebuf, read_ret); + } + if ((options & BPC_OPT_MD5) == BPC_OPT_MD5) { + ld_MD5Update(&md5_ctx, filebuf, read_ret); + } + if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { + SHA1Update(&sha1_ctx, filebuf, read_ret); + } + if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { + if (dent->size > 262144) { + + preread_filepos = filepos - read_ret; + + if (preread_filepos > 1048576) { + /* + * If we're only using the BPC hash, then we + * don't need to continue reading. + */ + if ((options & (BPC_OPT_MD4 | \ + BPC_OPT_MD5 | \ + BPC_OPT_SHA1 | \ + BPC_OPT_BPCHASH)) == BPC_OPT_BPCHASH) { + break; + } + } + + if (preread_filepos < 131072 || + (preread_filepos < bpc_hashstop && filepos > (bpc_hashstop - 131072))) { + if (filepos >= 131072 && preread_filepos < 131072) { + read_ret = read_ret - (filepos - 131072); + ld_MD5Update(&bpchash_ctx, filebuf, read_ret); + } else if (filepos >= bpc_hashstop && preread_filepos < bpc_hashstop) { + read_ret = read_ret - (filepos - bpc_hashstop); + ld_MD5Update(&bpchash_ctx, filebuf, read_ret); + } else if (filepos >= (bpc_hashstop - 131072) && preread_filepos < (bpc_hashstop - 131072)) { + read_ret = filepos - (bpc_hashstop - 131072); + ld_MD5Update(&bpchash_ctx, filebuf + (bpc_hashstop - 131072) - preread_filepos, read_ret); + } else { + ld_MD5Update(&bpchash_ctx, filebuf, read_ret); + } + } + } else { + ld_MD5Update(&bpchash_ctx, filebuf, read_ret); + } + } + } + + /* + * If no errors occured, the EOF bit will have been + * set and we can trust the hashes well enough to + * commit them to the stream. + */ + if (read_ret >= 0) { + if ((options & BPC_OPT_MD4) == BPC_OPT_MD4) { + rsaref_MD4Final(digest, &md4_ctx); + + id = htons(BPC_ATTRID_MD4); + len = htonl(16); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, digest, 16); + buf += 16; + } + if ((options & BPC_OPT_MD5) == BPC_OPT_MD5) { + ld_MD5Final(digest, &md5_ctx); + + id = htons(BPC_ATTRID_MD5); + len = htonl(16); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, digest, 16); + buf += 16; + } + if ((options & BPC_OPT_SHA1) == BPC_OPT_SHA1) { + SHA1Final(digest, &sha1_ctx); + + id = htons(BPC_ATTRID_SHA1); + len = htonl(20); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, digest, 20); + buf += 20; + } + if ((options & BPC_OPT_BPCHASH) == BPC_OPT_BPCHASH) { + ld_MD5Final(digest, &bpchash_ctx); + + id = htons(BPC_ATTRID_BPCHASH); + len = htonl(16); + + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + + memcpy(buf, &len, sizeof(len)); + buf += sizeof(len); + + memcpy(buf, digest, 16); + buf += 16; + } + } + + backuppc_closefile(dent); + } + } + + /* If we can't fit the termination marker in, scrap the entire buffer. */ + if ((outbuflen - (buf - outbuf)) >= sizeof(id)) { + id = htons(0xffff); + memcpy(buf, &id, sizeof(id)); + buf += sizeof(id); + } else { + buf = outbuf; + } + + return(buf - outbuf); +} + +/* + * SYNOPSIS: + * static void backuppc_bufuse( + * struct backuppc_client_info *node, + * const size_t amount + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_bufuse(struct backuppc_client_info *node, const size_t amount) { + + assert(amount <= node->bufused); + assert(amount <= node->bufsize); + + node->buf += amount; + node->bufused -= amount; + node->bufsize -= amount; + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_bufmemcpy(struct backuppc_client_info *src, void *dst, size_t n) { + + if (src->bufsize < n) { + return(0); + } + if (src->bufused < n) { + return(0); + } + + memcpy(dst, src->buf, n); + backuppc_bufuse(src, n); + + return(1); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_outbufmemcpy(struct backuppc_client_info *dst, const void *src, size_t n) { + size_t bytesleft; + unsigned long newoutbufsize; + void *newbuf_s, *newbuf; + + /* If we've been asked to write more data than will ever fit in the + buffer, change the buffer. */ + if (n > dst->outbufsize_s) { + if (dst->outbufsize_s == BPC_MAXOUTBUF_LEN) { + /* The buffer is as large as it will get, but it is + still not large enough. Must be invalid data. */ + dst->invalid_data = 1; + return(0); + } + + newoutbufsize = dst->outbufsize_s * 2; + + if (newoutbufsize > BPC_MAXOUTBUF_LEN) { + newoutbufsize = BPC_MAXOUTBUF_LEN; + } + + newbuf_s = realloc(dst->outbuf_s, newoutbufsize); + + if (!newbuf_s) { + return(0); + } + + newbuf = newbuf_s + (dst->outbuf - dst->outbuf_s); + + dst->outbufsize += (newoutbufsize - dst->outbufsize_s); + dst->outbufsize_s = newoutbufsize; + dst->outbuf_s = newbuf_s; + dst->outbuf = newbuf; + + if (n > dst->outbufsize_s) { + return(0); + } + } + + bytesleft = dst->outbufsize - dst->outbufused; + + if (bytesleft < n) { + return(0); + } + + memcpy(dst->outbuf + dst->outbufused, src, n); + dst->outbufused += n; + + return(1); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * For type = BPC_DT_STRING_PTR, must be a pointer to (char *) NULL initially, or allocated + * size + 1 or greater. + * + */ +static int backuppc_readvalues(struct backuppc_client_info *client, backuppc_recv_mark_t rmid, ...) { + struct backuppc_client_prochandle *ph; + backuppc_datatypes_t typeid; + va_list ap; + uint8_t *u8v; + uint16_t *u16v; + uint32_t *u32v; + uint64_t *u64v; + char *cpv, **cppv; + void *vpv = NULL, **vppv; + size_t vpv_len; + int argcnt; + + ph = client->process_handle; + + if (ph->recv_sect[rmid]) { + return(1); + } + + va_start(ap, rmid); + for (argcnt = 0;; argcnt++) { + typeid = va_arg(ap, backuppc_datatypes_t); + + if (typeid == BPC_DT_END) { + break; + } + + switch (typeid) { + case BPC_DT_UINT8: + u8v = va_arg(ap, uint8_t *); + vpv_len = sizeof(*u8v); + vpv = u8v; + break; + case BPC_DT_UINT16: + u16v = va_arg(ap, uint16_t *); + vpv_len = sizeof(*u16v); + vpv = u16v; + break; + case BPC_DT_UINT32: + u32v = va_arg(ap, uint32_t *); + vpv_len = sizeof(*u32v); + vpv = u32v; + break; + case BPC_DT_UINT64: + u64v = va_arg(ap, uint64_t *); + vpv_len = sizeof(*u64v); + vpv = u64v; + break; + case BPC_DT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_DT_BYTEARRAY_PTR: + vpv_len = va_arg(ap, size_t); + vppv = va_arg(ap, void **); + + if (*vppv == NULL) { + *vppv = malloc(vpv_len); + vpv = *vppv; + } + break; + case BPC_DT_STRING: + vpv_len = va_arg(ap, size_t); + vpv_len--; + cpv = va_arg(ap, char *); + cpv[vpv_len] = '\0'; + vpv = cpv; + break; + case BPC_DT_STRING_PTR: + vpv_len = va_arg(ap, size_t); + cppv = va_arg(ap, char **); + if (*cppv == NULL) { + cpv = *cppv = malloc(vpv_len + 1); + cpv[vpv_len] = '\0'; + } else { + cpv = *cppv; + } + vpv = cpv; + break; + default: + return(0); + } + + if (argcnt <= ph->rv_idx) { + continue; + } + + if (!backuppc_bufmemcpy(client, vpv, vpv_len)) { + return(0); + } + + switch (typeid) { + case BPC_DT_UINT16: + u16v = vpv; + *u16v = ntohs(*u16v); + break; + case BPC_DT_UINT32: + u32v = vpv; + *u32v = ntohl(*u32v); + break; + case BPC_DT_UINT64: + u64v = vpv; + *u64v = ntohll(*u64v); + break; + default: + break; + } + + ph->rv_idx = argcnt; + } + va_end(ap); + + ph->rv_idx = -1; + + if (rmid != BPC_RM_NONE) { + ph->recv_sect[rmid] = 1; + } + + return(1); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_writevalues(struct backuppc_client_info *client, backuppc_send_mark_t smid, ...) { + struct backuppc_client_prochandle *ph; + backuppc_datatypes_t typeid; + va_list ap; + uint8_t u8v; + uint16_t u16v; + uint32_t u32v; + uint64_t u64v; + void *vpv; + char *cpv; + size_t vpv_len; + int argcnt; + + ph = client->process_handle; + + if (ph->sent_sect[smid]) { + return(1); + } + + va_start(ap, smid); + for (argcnt = 0;; argcnt++) { + typeid = va_arg(ap, backuppc_datatypes_t); + + if (typeid == BPC_DT_END) { + break; + } + + switch (typeid) { + case BPC_DT_UINT8: + u8v = va_arg(ap, int); + vpv_len = sizeof(u8v); + vpv = &u8v; + break; + case BPC_DT_UINT16: + u16v = va_arg(ap, int); + u16v = htons(u16v); + vpv_len = sizeof(u16v); + vpv = &u16v; + break; + case BPC_DT_UINT32: + u32v = va_arg(ap, uint32_t); + u32v = htonl(u32v); + vpv_len = sizeof(u32v); + vpv = &u32v; + break; + case BPC_DT_UINT64: + u64v = va_arg(ap, uint64_t); + u64v = htonll(u64v); + vpv_len = sizeof(u64v); + vpv = &u64v; + break; + case BPC_DT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_DT_STRING: + cpv = va_arg(ap, char *); + vpv_len = strlen(cpv); + vpv = cpv; + break; + case BPC_DT_BYTEARRAY_PTR: + case BPC_DT_STRING_PTR: + default: + return(0); + } + + if (argcnt <= ph->wv_idx) { + continue; + } + + if (!backuppc_outbufmemcpy(client, vpv, vpv_len)) { + return(0); + } + + ph->wv_idx = argcnt; + } + va_end(ap); + + ph->wv_idx = -1; + + if (smid != BPC_SM_NONE) { + ph->sent_sect[smid] = 1; + } + + return(1); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_listget_init(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + int i; + + ph = client->process_handle; + + for (i = 0; i < (sizeof(ph->dh) / sizeof(ph->dh[0])); i++) { + ph->dh[i] = NULL; + } + + ph->dhidx = 0; + ph->dent = NULL; + ph->options = 0; + ph->pathname = NULL; + ph->pathname_len = 0; + ph->excl_sect_len = 0; + ph->incl_sect_len = 0; + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_listget_fini(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + int i; + + ph = client->process_handle; + + for (i = 0; i < (sizeof(ph->dh) / sizeof(ph->dh[0])); i++) { + if (!ph->dh[i]) { + break; + } + + backuppc_closedir(ph->dh[i]); + + ph->dh[i] = NULL; + } + + if (ph->pathname) { + free(ph->pathname); + ph->pathname = NULL; + } + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_process_listget(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + ssize_t read_ret, get_attr_ret; + int i, sparse_block; + int recurse_dir; +#ifdef HAVE_STATFS + struct statfs dirinfo; + int statfs_ret; +#endif + + ph = client->process_handle; + + /* + * Require READ or READ-WRITE privileges to LIST/GET + */ + if (client->privs != BPC_PRIV_READ && client->privs != BPC_PRIV_RDWR) { + client->invalid_data = 1; + return(-1); + } + + /* + * Read the header information from the buffer. + */ + if (!backuppc_readvalues(client, BPC_RM_HEADER, + BPC_DT_UINT8, (uint8_t *) &ph->options, + BPC_DT_UINT32, (uint32_t *) &ph->excl_sect_len, + BPC_DT_UINT32, (uint32_t *) &ph->incl_sect_len, + BPC_DT_UINT32, (uint32_t *) &ph->pathname_len, + BPC_DT_END)) { + return(-1); + } + + /* + * Currently we do not handle client-specified exclude data. + * XXX: Fix this. + */ + if (ph->excl_sect_len != 0) { + client->invalid_data = 1; + return(-1); + } + if (ph->incl_sect_len != 0) { + client->invalid_data = 1; + return(-1); + } + + /* + * Do not allow the client to specify an insane pathname length. + */ + if (ph->pathname_len > BPC_MAXPATH_LEN) { + client->invalid_data = 1; + return(-1); + } + + if (!backuppc_readvalues(client, BPC_RM_PATHNAME, BPC_DT_STRING_PTR, (size_t) ph->pathname_len, (char **) &ph->pathname, BPC_DT_END)) { + return(-1); + } + + /* + * Once we've read the full header, update the status to indicate that + * further calls to this function will cause the outbuf to be updated. + */ + client->outdata_waiting = 1; + + if (!backuppc_writevalues(client, BPC_SM_PKT_HEADER, BPC_DT_UINT8, (uint8_t) (ph->cmd | 0x80), BPC_DT_END)) { + return(-1); + } + + if (ph->dh[0] == NULL) { + if (ph->pathname) { + ph->dh[0] = backuppc_opendir(ph->pathname); + + free(ph->pathname); + ph->pathname = NULL; + } + ph->dhidx = 0; + } + + while (1) { + if (!ph->dent) { + if (ph->dh[ph->dhidx]) { + ph->dent = backuppc_readdir(ph->dh[ph->dhidx]); + } else { + ph->dent = NULL; + } + + if (ph->dent == NULL) { + /* End of directory. */ + + if (ph->dh[ph->dhidx]) { + backuppc_closedir(ph->dh[ph->dhidx]); + } + + ph->dh[ph->dhidx] = NULL; + + if (ph->dhidx == 0) { + break; + } else { + ph->dhidx--; + continue; + } + } + + /* Clear the per-file indicators. */ + ph->sent_sect[BPC_SM_PATHNAME] = 0; + ph->sent_sect[BPC_SM_HEADER] = 0; + ph->sent_sect[BPC_SM_DATA_CLEANUP] = 0; + + get_attr_ret = backuppc_get_attr(ph->dent, ph->attrdata, sizeof(ph->attrdata), ph->options); + if (get_attr_ret >= 0) { + ph->attrlen = get_attr_ret; + } else { + ph->attrlen = 0; + } + } + + if (ph->cmd == BPC_CMD_GET && ph->dent->type == BPC_FILE_REG) { + if (ph->dent->fd < 0) { + backuppc_openfile(ph->dent, O_RDONLY, 0); + + /* If we can't open the file, skip it. */ + if (ph->dent->fd < 0) { + ph->dent = NULL; + continue; + } + + ph->bytes_written = 0; + ph->block_num = 0; + } + } + + if (!backuppc_writevalues(client, BPC_SM_HEADER, + BPC_DT_UINT8, (uint8_t) ph->dent->type, + BPC_DT_UINT32, (uint32_t) ph->attrlen, + BPC_DT_UINT64, (uint64_t) ph->dent->size, + BPC_DT_UINT32, (uint32_t) ph->tmpbufsize, + BPC_DT_UINT32, (uint32_t) strlen(ph->dent->fullpathname), + BPC_DT_STRING, (char *) ph->dent->fullpathname, + BPC_DT_BYTEARRAY, (size_t) ph->attrlen, (void *) ph->attrdata, + BPC_DT_END)) { + return(-1); + } + + /* Send the contents of the file. */ + while (ph->dent->fd >= 0) { + /* + * Read data into the tmpbuffer if it is empty. + */ + if (ph->tmpbufused == 0) { + read_ret = read(ph->dent->fd, ph->tmpbuf, ph->tmpbufsize); + + if (read_ret <= 0) { + /* + * If we can't read as many bytes as + * we said were in the file, send + * junk to pad the buffer. Perhaps + * we should make a list of files + * to re-transmit. (XXX) + */ + if (ph->bytes_written < ph->dent->size) { + read_ret = ph->tmpbufsize; + } else { + backuppc_closefile(ph->dent); + continue; + } + } + + ph->tmpbufused = read_ret; + + /* + * Do NOT send more than we've agreed to send, + * if we read more than the size fo the file, + * send only as many bytes as we've said the + * file contained. + */ + if ((ph->bytes_written + ph->tmpbufused) > ph->dent->size) { + ph->tmpbufused = ph->dent->size - ph->bytes_written; + } + + if (ph->dent->issparse) { + sparse_block = 1; + for (i = 0; i < ph->tmpbufused; i++) { + if (ph->tmpbuf[i] != '\0') { + sparse_block = 0; + } + } + } else { + sparse_block = 0; + } + + if (sparse_block) { + continue; + } + } + + /* + * We write the entire buffer here, even though it + * may contain garbage since we commited to fixed + * sized buffers. The other end will figure out + * that the file is too large and truncate it + * properly. We may omit sending blocks whose + * contents are completely 0s as this is the sign + * of an empty block in a sparse file. + */ + if (!backuppc_writevalues(client, BPC_SM_NONE, + BPC_DT_UINT32, (uint32_t) ph->block_num, + BPC_DT_BYTEARRAY, (size_t) ph->tmpbufsize, (void *) ph->tmpbuf, + BPC_DT_END)) { + return(-1); + } + + ph->bytes_written += ph->tmpbufused; + ph->block_num++; + + ph->tmpbufused = 0; + } + + /* If this is a get request, send the marker for end of the data stream. */ + if (ph->cmd == BPC_CMD_GET) { + if (!backuppc_writevalues(client, BPC_SM_DATA_CLEANUP, + BPC_DT_UINT32, (uint32_t) 0xFFFFFFFF, + BPC_DT_END)) { + return(-1); + } + } + + /* If this is a directory and we are to be recursive, follow it. */ + if (ph->dent->type == BPC_FILE_DIR && (ph->options & BPC_OPT_RECURSIVE) == BPC_OPT_RECURSIVE) { + recurse_dir = 1; +#if defined(HAVE_GETMNTINFO) + /* + * XXX: Determine whether or not the new path name is on a filesystem we backup (bsd) + */ +#elif defined(HAVE_STATFS) + /* + * XXX: Determine whether or not the new path name is on a filesystem we backup (linux) + * + * This should probably be made a configurable parameter. + */ + statfs_ret = statfs(ph->dent->fullpathname, &dirinfo); + if (statfs_ret == 0) { + switch (dirinfo.f_type) { + case NFS_SUPER_MAGIC: + case PROC_SUPER_MAGIC: + case DEVFS_SUPER_MAGIC: + case NCP_SUPER_MAGIC: + case SMB_SUPER_MAGIC: + case TMPFS_MAGIC: + case ISOFS_SUPER_MAGIC: + recurse_dir = 0; + break; + } + } +#endif + } else { + recurse_dir = 0; + } + + if (recurse_dir) { + + ph->dhidx++; + + if (ph->dhidx >= sizeof(ph->dh) / sizeof(ph->dh[0])) { + /* Refuse to overflow the buffer. */ + ph->dhidx--; + + client->invalid_data = 1; + + return(-1); + } + + ph->dh[ph->dhidx] = backuppc_opendir(ph->dent->fullpathname); + if (!ph->dh[ph->dhidx]) { + ph->dhidx--; + } + } + + ph->dent = NULL; + } + + if (!backuppc_writevalues(client, BPC_SM_CLEANUP, BPC_DT_UINT8, (uint8_t) 0xff, BPC_DT_END)) { + return(-1); + } + + backuppc_process_listget_fini(client); + backuppc_process_listget_init(client); + + return(0); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_auth_init(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + + ph = client->process_handle; + + ph->username = NULL; + ph->password = NULL; + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_auth_fini(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + + ph = client->process_handle; + + if (ph->username) { + free(ph->username); + ph->username = NULL; + } + + if (ph->password) { + free(ph->password); + ph->password = NULL; + } + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_process_auth(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + backuppc_status_t auth_stat = BPC_STATUS_UNKNOWN; + char *crypt_passwd; + + ph = client->process_handle; + + if (!backuppc_readvalues(client, BPC_RM_HEADER, + BPC_DT_UINT16, (uint16_t *) &ph->username_len, + BPC_DT_UINT16, (uint16_t *) &ph->password_len, + BPC_DT_END)) { + return(-1); + } + + if (ph->username_len > BPC_MAXUSERNAME_LEN) { + client->invalid_data = 1; + } + + if (ph->password_len > BPC_MAXPASSWORD_LEN) { + client->invalid_data = 1; + } + + if (!backuppc_readvalues(client, BPC_RM_AUTHDATA, + BPC_DT_STRING_PTR, (size_t) ph->username_len, (char **) &ph->username, + BPC_DT_STRING_PTR, (size_t) ph->password_len, (char **) &ph->password, + BPC_DT_END)) { + return(-1); + } + + /* Do authentication ... */ + + /* Attempt to authenticate with the master password. */ + crypt_passwd = SHA1sum(ph->password); + if (strcmp(crypt_passwd, BPC_CONF_MASTER_PASSWORD) == 0) { + auth_stat = BPC_STATUS_OKAY; + client->privs = BPC_PRIV_RDWR; + } else { + /* + * Perform authentication of the user + */ + client->privs = bpcd_auth_verify(ph->username, crypt_passwd, client->addr.s_addr); + + /* + * If the authentication subsystem returns an error, assign + * the session no privileges and declare failure. + */ + if (client->privs == BPC_PRIV_ERROR) { + auth_stat = BPC_STATUS_FAILED; + client->privs = BPC_PRIV_NONE; + } else { + auth_stat = BPC_STATUS_OKAY; + } + } + + if (auth_stat == BPC_STATUS_OKAY) { +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Authenticated \"%s\" from %s.", ph->username, inet_ntoa(client->addr)); +#endif + } else { +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Failed login attempt for \"%s\" from %s.", ph->username, inet_ntoa(client->addr)); +#endif + } + + if (auth_stat == BPC_STATUS_UNKNOWN) { + auth_stat = BPC_STATUS_FAILED; + } + + /* + * Send reply. + */ + if (!backuppc_writevalues(client, BPC_SM_AUTHSTATUS, + BPC_DT_UINT8, (uint8_t) BPC_CMD_AUTH_REPLY, + BPC_DT_UINT8, (uint8_t) auth_stat, + BPC_DT_END)) { + return(-1); + } + + backuppc_process_auth_fini(client); + backuppc_process_auth_init(client); + + return(0);; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_client_init(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + int i; + + ph = malloc(sizeof(*ph)); + + if (!ph) { + return; + } + + ph->cmd = BPC_CMD_NONE; + + for (i = 0; i < (sizeof(ph->sent_sect) / sizeof(ph->sent_sect[0])); i++) { + ph->sent_sect[i] = 0; + } + + for (i = 0; i < (sizeof(ph->recv_sect) / sizeof(ph->recv_sect[0])); i++) { + ph->recv_sect[i] = 0; + } + + ph->tmpbufsize = backuppc_writeblock_size; + ph->tmpbuf = calloc(ph->tmpbufsize, 1); + ph->tmpbufused = 0; + ph->wv_idx = -1; + ph->rv_idx = -1; + + client->process_handle = ph; + + backuppc_process_auth_init(client); + backuppc_process_listget_init(client); + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void backuppc_process_client_fini(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + + ph = client->process_handle; + + if (!ph) { + return; + } + + backuppc_process_auth_fini(client); + backuppc_process_listget_fini(client); + + if (ph->tmpbuf) { + free(ph->tmpbuf); + } + + free(ph); + + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_process_client(struct backuppc_client_info *client) { + struct backuppc_client_prochandle *ph; + uint8_t tmp_cmd; + int cmd_ret; + int i; + + ph = client->process_handle; + + if (!ph) { + client->invalid_data = 1; + return(0); + } + + /* + * This loop processes a single command from the client->buf per + * iteration. It passes the control to a delegate function. + * The delegate function should return a negative value to + * indicate that no more data can be read from the current + * buffer. + */ + do { + if (ph->cmd == BPC_CMD_NONE) { + if (!backuppc_readvalues(client, BPC_RM_NONE, + BPC_DT_UINT8, (uint8_t *) &tmp_cmd, + BPC_DT_END)) { + return(0); + } + + ph->cmd = tmp_cmd; + } + + switch (ph->cmd) { + case BPC_CMD_AUTH: + cmd_ret = backuppc_process_auth(client); + break; + case BPC_CMD_LIST: + cmd_ret = backuppc_process_listget(client); + break; + case BPC_CMD_GET: + cmd_ret = backuppc_process_listget(client); + break; + case BPC_CMD_PUT: + case BPC_CMD_NONE: + default: + /* Sending an unknown command is considered invalid + data. */ + cmd_ret = -1; + client->invalid_data = 1; + break; + } + + if (cmd_ret < 0) { + break; + } + + ph->cmd = BPC_CMD_NONE; + + for (i = 0; i < (sizeof(ph->sent_sect) / sizeof(ph->sent_sect[0])); i++) { + ph->sent_sect[i] = 0; + } + + for (i = 0; i < (sizeof(ph->recv_sect) / sizeof(ph->recv_sect[0])); i++) { + ph->recv_sect[i] = 0; + } + + ph->wv_idx = -1; + ph->rv_idx = -1; + + client->outdata_waiting = 0; + } while (client->bufused > 0); + + return(0); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_verify_addr(uint32_t addr) { + return(1); +} + +int backuppc_switchupdate(char *src, char *dst, const int argc, char **argv) { + size_t fread_ret; + FILE *ifp, *ofp; + char buf[1024]; + char *newargv[1024]; +#ifdef _USE_WIN32_ + char quotebuf[8192]; +#endif + int newargc = 0, i; + + ifp = fopen(src, "rb"); + if (!ifp) { + unlink(src); + return(0); + } + + ofp = fopen(dst, "wb"); + if (!ofp) { + fclose(ifp); + return(0); + } + + while (!feof(ifp)) { + fread_ret = fread(buf, sizeof(buf[0]), sizeof(buf), ifp); + if (fread_ret == 0) { + continue; + } + + fwrite(buf, sizeof(buf[0]), fread_ret, ofp); + } + + fclose(ofp); + fclose(ifp); + + unlink(src); + +#ifdef _USE_WIN32_ + /* + * More of that lovely Windows-requiring-exec-args-to-be-quoted. + */ + snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", dst); + newargv[newargc++] = strdup(quotebuf); +#else + newargv[newargc++] = dst; +#endif + newargv[newargc++] = "--DeleteFile"; + newargv[newargc++] = src; + + /* + * We must skip the "--Switch" and "--Source" and "--Destination" + * parameters. They are the first few arguments. + */ + for (i = 6; i < argc; i++) { +#ifdef _USE_WIN32_ + /* + * More of that lovely Windows-requiring-exec-args-to-be-quoted + */ + snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", argv[i]); + newargv[newargc++] = strdup(quotebuf); +#else + newargv[newargc++] = argv[i]; +#endif + } + newargv[newargc++] = NULL; + + execv(dst, newargv); + + return(0); +} + +int backuppc_update(const char *url, const int argc, char **argv) { +#ifdef HAVE_LIBOPENNET + size_t fread_ret; + NETFILE *ifp, *cfp; + FILE *ofp; + char buf[8192], localfile[1024], tmpfile[1024], curdir[1024], *tmpdir = NULL; +#ifdef _USE_WIN32_ + char quotebuf[8192]; +#endif + char checkurl[1024], remote_vers[128]; + char *newargv[1024]; + int newargc = 0, i; + + if (!url) { + return(1); + } + + /* + * Check to see if the remote binary is a newer version than ours + */ + snprintf(checkurl, sizeof(checkurl), "%s.vers", url); + cfp = fopen_net(checkurl, "r"); + if (!cfp) { + return(1); + } + + remote_vers[0] = '\0'; + + fgets_net(remote_vers, sizeof(remote_vers), cfp); + + fclose_net(cfp); + + /* + * Ignore bogus version strings + */ + if (strlen(remote_vers) <= 0) { + return(1); + } + + if (remote_vers[strlen(remote_vers) - 1] == '\n') { + remote_vers[strlen(remote_vers) - 1] = '\0'; + } + + if (strcmp(remote_vers, PACKAGE_VERSION) == 0) { + /* + * If the remote version string is identical to the local + * version string, nothing needs to be done. + */ + return(1); + } + + /* + * Download the remote binary to the temporary directory. + */ +#ifdef HAVE_GETENV + tmpdir = getenv("TMPDIR"); +#endif + + if (!tmpdir) { +#ifdef _USE_WIN32_ + tmpdir = "c:/temp"; +#else + tmpdir = "/tmp"; +#endif + } + + backuppc_mkdir(tmpdir); + + srand(getpid() + time(NULL)); + + snprintf(tmpfile, sizeof(tmpfile), "%s/backuppcd-%i%i%s", tmpdir, rand(), rand(), EXEEXT); + +#ifdef _USE_WIN32_ + if (isalpha(argv[0][0]) && argv[0][1] == ':') { +#else + if (argv[0][0] == '/') { +#endif + snprintf(localfile, sizeof(localfile), "%s", argv[0]); + if (access(localfile, R_OK) != 0) { + snprintf(localfile, sizeof(localfile), "%s%s", argv[0], EXEEXT); + } + } else if (argv[0][0] == '.' || strchr(argv[0], '/')) { + getcwd(curdir, sizeof(curdir)); + curdir[sizeof(curdir) - 1] = '\0'; + snprintf(localfile, sizeof(localfile), "%s/%s", curdir, argv[0]); + if (access(localfile, R_OK) != 0) { + snprintf(localfile, sizeof(localfile), "%s/%s%s", curdir, argv[0], EXEEXT); + } + } else { + if (backuppc_binfile) { + snprintf(localfile, sizeof(localfile), "%s", backuppc_binfile); + } else { +#ifdef _USE_WIN32_ + getcwd(curdir, sizeof(curdir)); + curdir[sizeof(curdir) - 1] = '\0'; + snprintf(localfile, sizeof(localfile), "%s/%s", curdir, argv[0]); + if (access(localfile, R_OK) != 0) { + snprintf(localfile, sizeof(localfile), "%s/%s%s", curdir, argv[0], EXEEXT); + } + if (access(localfile, R_OK) != 0) { + snprintf(localfile, sizeof(localfile), "%s/%s", EXECPREFIX, "backuppcd.exe"); + } +#else + /* Search the PATH for ourselves. */ + CHECKPOINT; + localfile[0] = '\0'; + return(0); +#endif + } + } + + ofp = fopen(tmpfile, "wb"); + if (!ofp) { + return(0); + } + + ifp = fopen_net(url, "rb"); + if (!ifp) { + fclose(ofp); + unlink(tmpfile); + return(0); + } + + while (!feof_net(ifp)) { + fread_ret = fread_net(buf, sizeof(buf[0]), sizeof(buf), ifp); + if (fread_ret == 0) { + continue; + } + + fwrite(buf, sizeof(buf[0]), fread_ret, ofp); + } + + fclose_net(ifp); + fclose(ofp); + + chmod(tmpfile, S_IXUSR | S_IRUSR | S_IWUSR); + + newargv[newargc++] = tmpfile; + newargv[newargc++] = "--Switch"; + newargv[newargc++] = "--Source"; + newargv[newargc++] = tmpfile; + newargv[newargc++] = "--Destination"; + +#ifdef _USE_WIN32_ + /* + * Under Windows, we must QUOTE EVERY ARGUMENT that might contain a + * space, otherwise, Windows gets confused and splits them into + * many arguments. This may be a mingw32 problem, not sure. (XXX) + */ + snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", localfile); + newargv[newargc++] = strdup(quotebuf); +#else + newargv[newargc++] = localfile; +#endif + + /* + * Append all command line arguments given to the current instance of + * BackupPCd to pass to the child. + */ + for (i = 1; i < argc; i++) { +#ifdef _USE_WIN32_ + /* + * More of that lovely Windows quoting. + */ + snprintf(quotebuf, sizeof(quotebuf), "\"%s\"", argv[i]); + newargv[newargc++] = strdup(argv[i]); +#else + newargv[newargc++] = argv[i]; +#endif + } + newargv[newargc++] = NULL; + + execv(tmpfile, newargv); + + unlink(tmpfile); +#endif + return(0); +} + +/* + * SYNOPSIS: + * int backuppc_loop( + * int argc, + * char **argv, + * ); + * + * ARGUMENTS: + * int argc Argument count, should be same as passed + * to main() + * char **argv Argument vector, should be same as passwd to + * main() + * + * RETURN VALUE: + * This function will only return `EXIT_SUCCESS' + * + * NOTES: + * This function is the primary worker loop. + * + */ +int backuppc_loop(int argc, char **argv) { + struct backuppc_client_info *cinfo = NULL, *curnode, *prevnode, *nextnode; + struct sockaddr_in client_addr; + struct timeval tmout; + socklen_t client_addr_len; + ssize_t recv_ret, send_ret; + fd_set rfds, wfds; +#ifdef HAVE_FCNTL + long sock_flags; +#endif + int master_fd, max_fd, client_fd; + int select_ret; + int need_cleanup = 0; + int error_count = 0; + int process_node; + time_t next_update, curr_time; + + WorkLoopStatus = LOOP_RUN; + + master_fd = net_listen(backuppc_port); + + max_fd = master_fd; + + next_update = time(NULL) + BPC_UPDATE_INTERVAL; + + while (1) { + if (master_fd < 0 || error_count > 10) { + + WorkLoopStatus = LOOP_STOP; + + break; + } + + /* + * Reset the structures needed for the select() call. + */ + max_fd = master_fd; + + FD_ZERO(&rfds); + FD_ZERO(&wfds); + FD_SET(master_fd, &rfds); + for (curnode = cinfo; curnode; curnode = curnode->_next) { + + assert(curnode != curnode->_next); + + if (curnode->fd < 0) { + continue; + } + + if (curnode->fd > max_fd) { + max_fd = curnode->fd; + } + + FD_SET(curnode->fd, &rfds); + + if (curnode->outdata_waiting || (curnode->outbufused > 0)) { + FD_SET(curnode->fd, &wfds); + } + } + +#ifdef _USE_WIN32_ + /* + * Under win32 we might be asked by ourselves (thread) to quit + * so we should do this in a reasonable amount of time. + */ + tmout.tv_sec = 10; + tmout.tv_usec = 0; +#else + if (need_cleanup) { + /* + * If clean-up has been requested, set the timeout to + * a smaller value so we can perform it after a + * reasonable amount of idle time. + */ + tmout.tv_sec = 120; + tmout.tv_usec = 0; + } else { + tmout.tv_sec = 86400; + tmout.tv_usec = 0; + } +#endif + + select_ret = select(max_fd + 1, &rfds, &wfds, NULL, &tmout); + +#ifdef _USE_WIN32_ + /* + * If we've been asked to terminate by a concurrent thread + * set our status to LOOP_STOP (not LOOP_DONE) and + * terminate the infinite loop. + */ + if (WorkLoopStatus != LOOP_RUN) { + WorkLoopStatus = LOOP_STOP; + break; + } +#endif + + /* + * If select() goes insane, don't get stuck in an endless + * loop. + */ + if (select_ret < 0) { + error_count++; + continue; + } + + error_count = 0; + + /* + * Time-out section. Handle maintenance taks when there is + * idle time. + */ + if (select_ret == 0) { + /* + * Perform automatic update if available. + */ + if (backuppc_updateurl || backuppc_notifyserv) { + curr_time = time(NULL); + if (curr_time >= next_update) { + if (backuppc_updateurl) { + backuppc_update(backuppc_updateurl, argc, argv); + } + if (backuppc_notifyserv) { + backuppc_notify(backuppc_notifyserv, backuppc_notifyport, NULL); + } + next_update = curr_time + BPC_UPDATE_INTERVAL; + } + } + + /* + * If clean-up has been requested, perform it now. + */ + if (need_cleanup) { + prevnode = NULL; + curnode = cinfo; + while (curnode) { + if (curnode->fd == -1) { + /* Remove dead sockets from the list. */ + if (prevnode) { + prevnode->_next = curnode->_next; + } else { + cinfo = curnode->_next; + } + + /* Perform client de-initialization + and maintenance. */ + if (curnode->buf_s) { + free(curnode->buf_s); + } + + if (curnode->outbuf_s) { + free(curnode->outbuf_s); + } + + backuppc_process_client_fini(curnode); + +#if defined(HAVE_SYSLOG) && defined(DEBUG) + syslog(LOG_INFO, "Cleaned connection from %s", inet_ntoa(curnode->addr)); +#endif + + nextnode = curnode->_next; + + free(curnode); + + curnode = nextnode; + + continue; + } + + prevnode = curnode; + + curnode = curnode->_next; + } + + need_cleanup = 0; + } + + continue; + } + + /* Handle incoming connections first. */ + if (FD_ISSET(master_fd, &rfds)) { + client_addr_len = sizeof(client_addr); + client_fd = accept(master_fd, (struct sockaddr *) &client_addr, &client_addr_len); + + if (client_fd < 0) { + continue; + } + + if (!backuppc_verify_addr(ntohl(client_addr.sin_addr.s_addr))) { +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Closing connection from unauthorized client %s", inet_ntoa(client_addr.sin_addr)); +#endif + net_close(client_fd); + continue; + } +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Accepted connection from %s", inet_ntoa(client_addr.sin_addr)); +#endif + + if (client_fd > max_fd) { + max_fd = client_fd; + } + +#ifdef HAVE_FCNTL + /* Make the socket non-blocking, so partial writes can occur. */ + sock_flags = fcntl(client_fd, F_GETFL); + if (sock_flags <= 0) { + sock_flags |= O_NONBLOCK; + fcntl(client_fd, F_SETFL, sock_flags); + } +#endif + + curnode = malloc(sizeof(*curnode)); + + if (curnode == NULL) { + net_close(client_fd); + continue; + } + + /* + * Initialize all members for the node to sane values. + */ + curnode->buf = NULL; + curnode->buf_s = NULL; + curnode->bufsize = 0; + curnode->bufsize_s = 0; + curnode->bufused = 0; + curnode->outbufsize = BPC_OUTBUF_LEN; + curnode->outbuf = malloc(curnode->outbufsize); + curnode->outbuf_s = curnode->outbuf; + curnode->outbufsize_s = curnode->outbufsize; + curnode->outbufused = 0; + curnode->outdata_waiting = 0; + curnode->tx_error_count = 0; + curnode->rx_error_count = 0; + curnode->process_handle = NULL; + curnode->privs = BPC_PRIV_NONE; + curnode->fd = client_fd; + curnode->invalid_data = 0; + memcpy(&curnode->addr, &client_addr.sin_addr, sizeof(client_addr.sin_addr)); + curnode->_next = cinfo; + + /* + * Ask the "process_client" routine to initialize + * its "proc_handle" and related members. + */ + backuppc_process_client_init(curnode); + + cinfo = curnode; + + continue; + } + + /* Process data from any connected clients. */ + for (curnode = cinfo; curnode; curnode = curnode->_next) { + /* + * Skip terminated nodes. + */ + if (curnode->fd < 0) { + continue; + } + + /* + * If this node has been generating excessive read + * or write errors, terminate it. + */ + if (curnode->tx_error_count > 10 || curnode->rx_error_count > 10) { +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Closing connection from %s for excessive errors.", inet_ntoa(curnode->addr)); +#endif + net_close(curnode->fd); + curnode->fd = -1; + + need_cleanup = 1; + continue; + } + + process_node = 0; + + if (FD_ISSET(curnode->fd, &wfds)) { + /* + * if the socket is writable and we have data + * to write to it, attempt to do so. + */ + if (curnode->outbufused > 0 && curnode->outbuf) { + send_ret = send(curnode->fd, curnode->outbuf, curnode->outbufused, 0); + + if (send_ret > 0) { + curnode->outbuf += send_ret; + curnode->outbufsize -= send_ret; + curnode->outbufused -= send_ret; + + /* Reset error count on successful transmission. */ + curnode->tx_error_count = 0; + } else { + /* Note errors that occur. */ + curnode->tx_error_count++; + } + } else { + /* + * If the node was checked for + * writability and it was, but we have + * no data to write to it, we must be + * stalled somewhere, for debugging + * we will print out a little message + */ + PRINTERR_D("Socket writable but no data to write. Stalled."); + } + + /* If there is no data in the buffer, but it has been shrunk, enlarge it. */ + if (curnode->outbuf != NULL && curnode->outbufsize != curnode->outbufsize_s && curnode->outbufused ==0) { + curnode->outbuf = NULL; + } + + /* If the buffer is uninitialized or emptied, give us a clean slate. */ + if (curnode->outbuf == NULL) { + if (curnode->outbuf_s) { + curnode->outbuf = curnode->outbuf_s; + curnode->outbufsize = curnode->outbufsize_s; + curnode->outbufused = 0; + } else { + curnode->outbufsize = BPC_OUTBUF_LEN; + curnode->outbuf = malloc(curnode->outbufsize); + curnode->outbuf_s = curnode->outbuf; + curnode->outbufsize_s = curnode->outbufsize; + curnode->outbufused = 0; + } + } + } + + /* + * If there is more data to be written for this + * socket, continue processing it. + */ + if (curnode->outdata_waiting) { + process_node = 1; + } + + /* + * If the socket has data waiting to be read, attempt + * to read it. + */ + if (FD_ISSET(curnode->fd, &rfds)) { + /* + * If there is no data in the buffer, but it + * has been shrunk, prepare it for + * enlargement. + **/ + if (curnode->buf != NULL && curnode->bufsize != curnode->bufsize_s && curnode->bufused == 0) { + curnode->buf = NULL; + } + + /* + * If the buffer is uninitialized or emptied, + * give us a clean slate. + */ + if (curnode->buf == NULL) { + if (curnode->buf_s) { + curnode->buf = curnode->buf_s; + curnode->bufsize = curnode->bufsize_s; + curnode->bufused = 0; + } else { + curnode->bufsize = BPC_BUF_LEN; + curnode->buf = malloc(curnode->bufsize); + curnode->buf_s = curnode->buf; + curnode->bufsize_s = curnode->bufsize; + curnode->bufused = 0; + } + } + + /* + * If the buffer is entirely used, but has + * been shrunk, move the data around to + * make more room. + */ + if (curnode->bufused == curnode->bufsize && curnode->bufsize != curnode->bufsize_s) { + memmove(curnode->buf_s, curnode->buf, curnode->bufused); + curnode->bufsize = curnode->bufsize_s; + curnode->buf = curnode->buf_s; + } + + /* + * If there is space in the buffer, read data into it. + */ + if ((curnode->bufsize - curnode->bufused) > 0) { + recv_ret = recv(curnode->fd, curnode->buf + curnode->bufused, curnode->bufsize - curnode->bufused, 0); + + if (recv_ret == 0) { + /* + * A zero return code indicates + * end of file, free the + * descriptor and cleanup. + */ +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Closing connection from %s", inet_ntoa(curnode->addr)); +#endif + net_close(curnode->fd); + curnode->fd = -1; + + need_cleanup = 1; + } else if (recv_ret < 0) { + /* + * If we had an error reading + * from the socket, increase + * its error count. + */ + curnode->rx_error_count++; + + } else { + /* + * Mark the newly used space + * and ask that the node be + * processed. + */ + curnode->bufused += recv_ret; + + process_node = 1; + + /* Reset error count on success. */ + curnode->rx_error_count = 0; + } + } else { + /* Consider the buffer filling up an error. */ + curnode->rx_error_count++; + + /* + * Attempt to process the node to free + * up buffer space. + */ + process_node = 1; + } + } + + if (process_node) { + /* + * If the output buffer is unallocated at this + * point something has gone horribly wrong. + * Do not attempt to process a client with + * no output buffer. + */ + if (curnode->outbuf == NULL) { + curnode->tx_error_count += 100; + curnode->rx_error_count += 100; + error_count++; + continue; + } + + /* + * If the output buffer is completely full, do + * not attempt to process more information on + * this node, since we'll have nowhere to + * write results anyway. Print out a debug + * message when this happens. + */ + if (curnode->outbufused == curnode->outbufsize) { + PRINTERR_D("Asked to process node with no buffer space available. Stalled."); + continue; + } + + /* + * Actually process the node. + */ + backuppc_process_client(curnode); + + /* + * If the processing indicates that the buffer + * has invalid data in it, terminate the client + * and ask for cleanup. + */ + if (curnode->invalid_data) { +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Closing connection from %s for sending invalid data.", inet_ntoa(curnode->addr)); +#endif + net_close(curnode->fd); + curnode->fd = -1; + need_cleanup = 1; + } + } + } + } + + if (master_fd >= 0) { + net_close(master_fd); + } + +#ifdef _USE_WIN32_ + backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; + backuppcServiceStat.dwWaitHint = 0; + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); +#endif + + WorkLoopStatus = LOOP_DONE; + + return(EXIT_SUCCESS); +} + +#ifdef _USE_WIN32_ +/* + * SYNOPSIS: + * VOID WINAPI backuppcServiceControl( + * DWORD request + * ); + * + * ARGUMENTS: + * DWORD request Action that is requested, only SERVICE_CONTROL_STOP + * and SERVICE_CONTROL_SHUTDOWN are acceptable. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function should be run in the same process as the primary worker + * loop (backuppc_loop()). It will set the Win32 service status + * when asked to STOP (or SHUTDOWN). It asks the main worker loop to + * terminate, which can take up to 10s (10000ms). When it is called and + * the worker thread has finished (i.e., set WorkLoopStatus to LOOP_DONE) + * it exits as well. + * + */ +VOID WINAPI backuppcServiceControl(DWORD request) { + /* We only handle the `STOP' and `SHUTDOWN' requests. */ + if (request != SERVICE_CONTROL_STOP && request != SERVICE_CONTROL_SHUTDOWN) { + return; + } + + /* Figure out what we're doing. */ + switch (WorkLoopStatus) { + case LOOP_RUN: + case LOOP_STOP: + /* If the loop is running, ask it to stop. */ + WorkLoopStatus = LOOP_STOP; + + /* Tell WIn32 that we're going peacfully. */ + backuppcServiceStat.dwCurrentState = SERVICE_STOP_PENDING; + backuppcServiceStat.dwWaitHint = 10000; + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); + break; + case LOOP_DONE: + /* The loop has finished and we can go away now. */ + backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; + backuppcServiceStat.dwWaitHint = 0; + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); + + exit(EXIT_SUCCESS); + + break; + } + + return; +} + +/* + * SYNOPSIS: + * void WINAPI backuppcServiceStart( + * DWORD argc + * LPTSTR *argv + * ); + * ARGUMENTS: + * DWORD argc Number of arguments + * LPTSTR *argv Argument data + * + * RETURN VALUE: + * (none) + * + * NOTES: + * This function is called by `StartServiceCtrlDispatcher'. It registers + * the service and updates its status information before and after calling + * the main worker loop (backuppc_loop()). + * + */ +void WINAPI backuppcServiceStart(DWORD argc, LPTSTR *argv) { + backuppcServiceStat.dwServiceType = SERVICE_WIN32; + backuppcServiceStat.dwCurrentState = SERVICE_START_PENDING; + backuppcServiceStat.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; + backuppcServiceStat.dwWin32ExitCode = 0; + backuppcServiceStat.dwServiceSpecificExitCode = 0; + backuppcServiceStat.dwCheckPoint = 0; + backuppcServiceStat.dwWaitHint = 0; + + backuppcServiceStat_handle = RegisterServiceCtrlHandler(svcName, backuppcServiceControl); + + if (backuppcServiceStat_handle == (SERVICE_STATUS_HANDLE) 0) { + fprintf(stderr, "Could not register service: %i\n", (int) GetLastError()); + return; + } + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); + + backuppcServiceStat.dwCurrentState = SERVICE_RUNNING; + backuppcServiceStat.dwCheckPoint = 0; + backuppcServiceStat.dwWaitHint = 0; + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); + + backuppc_loop(argc, argv); + + backuppcServiceStat.dwCurrentState = SERVICE_STOPPED; + backuppcServiceStat.dwCheckPoint = 0; + backuppcServiceStat.dwWaitHint = 0; + SetServiceStatus(backuppcServiceStat_handle, &backuppcServiceStat); + + return; +} +#endif /* _USE_WIN32_ */ + +/* + * SYNOPSIS: + * static int daemon_init(void); + * + * ARGUMENTS: + * (none) + * + * RETURN VALUE: + * This function returns `DAEMON_RET_FAILURE' or `DAEMON_RET_SUCCESS'. + * If it was able to successfully launch as its own set of processes + * SUCCESS is returned, otherwise FAILURE is returned. + * + * NOTES: + * This is the primary daemonizing routine. Under win32 it creates a + * service (svcName) and sets its initialization function to the + * service start function (backuppcServiceStart). + * + */ +static int daemon_init(void) { + /* Default return value is failure, indicating that caller should + continue on. */ + int retval = DAEMON_RET_FAILURE; +#ifndef _USE_WIN32_ +#ifdef HAVE_FORK + FILE *pidfile_fp = NULL; + pid_t pid; + + unlink(SKIPSTARTFILE); + + close(STDIN_FILENO); + close(STDOUT_FILENO); + close(STDERR_FILENO); + +#ifdef HAVE_SETSID + setsid(); +#endif + + pid = fork(); + + if (pid > 0) { + /* Write the child PID to a file so we can read it to + shutdown. */ + pidfile_fp = fopen(BACKUPPC_PIDFILE, "w"); + if (pidfile_fp != NULL) { + fprintf(pidfile_fp, "%li\n", (long) pid); + fclose(pidfile_fp); + } + + /* Tell the parent process that we have created children, indicating that + it should terminate. */ + return(DAEMON_RET_SUCCESS); + } + + if (pid < 0) { + /* On a fork error, terminate everyone immediately. */ + exit(EXIT_FAILURE); + } + + /* The child returns FAILURE to indicate that it should not terminate, but + rather carry on processing. */ + + retval = DAEMON_RET_FAILURE; +#endif +#else + DWORD win32Error; + SERVICE_TABLE_ENTRY serviceTable[] = { + {svcName, backuppcServiceStart}, + { NULL, NULL} + }; + + if (!StartServiceCtrlDispatcher(serviceTable)) { + win32Error = GetLastError(); + switch (win32Error) { + case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT: + /* Print no error here because we're not being + run as a service yet. This will happen + later. CreateService() will cause a new + process to be created where this will + succeed. */ + break; + default: + fprintf(stderr, "Could not start service dispatcher: %i\n", (int) win32Error); + break; + } + } else { + /* We were able to start the "Control Dispatcher" so we + indicate success. This should tell the caller to + terminate since we'll be starting our own set of + processes. */ + retval = DAEMON_RET_SUCCESS; + } +#endif + return(retval); +} + +/* + * SYNOPSIS: + * static int daemon_stop(void); + * + * ARGUMENTS: + * (none) + * + * RETURN VALUE: + * Upon sucessfully stopping the running daemon, 0 is returned. Otherwise + * -1 is returned. + * + * NOTES: + * This function uses the Service Control functions on Win32. + * This function uses a pid file (BACKUPPC_PIDFILE) on POSIX platforms. + * + */ +static int daemon_stop(void) { + int retval = -1; +#ifndef _USE_WIN32_ + FILE *pidfile_fp = NULL; + char buf[128]; + pid_t pid; + int killret, unlinkret; + + pidfile_fp = fopen(BACKUPPC_PIDFILE, "r"); + if (pidfile_fp == NULL) { + fprintf(stderr, "Service is not running.\n"); + return(-1); + } + + fgets(buf, sizeof(buf), pidfile_fp); + pid = strtol(buf, NULL, 10); + + if (pid <= 0) { + fprintf(stderr, "Invalid process ID: %li\n", (long) pid); + return(-1); + } + + unlinkret = unlink(BACKUPPC_PIDFILE); + if (unlinkret < 0) { + fprintf(stderr, "Error removing pid file (\"%s\"): ", BACKUPPC_PIDFILE); + perror("unlink"); + } + + killret = kill(pid, 1); + if (killret < 0) { + perror("kill"); + return(-1); + } + +#ifdef HAVE_SYSLOG + syslog(LOG_INFO, "Terminating running backuppcd (pid = %lu)", (unsigned long) pid); +#endif + + retval = 0; +#else + /* Open a connection to the SCM if there isn't one already. */ + if (manager == NULL) { + manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); + if (manager == NULL) { + fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); + return(-1); + } + } + + /* Connect to our service. */ + service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); + if (service == NULL) { + fprintf(stderr, "Could not open service: %i\n", (int) GetLastError()); + return(-1); + } + + /* Ask ourselves to stop through the SCM. */ + if (!ControlService(service, SERVICE_CONTROL_STOP, &backuppcServiceStat)) { + if (GetLastError() != ERROR_SERVICE_NOT_ACTIVE) { + fprintf(stderr, "Could not stop service: %i\n", (int) GetLastError()); + return(-1); + } + } + + fprintf(stderr, "Service stopped.\n"); + + retval = 0; +#endif + return(retval); +} + +/* + * SYNOPSIS: + * static int daemon_remove(void); + * + * ARGUMENTS: + * (none) + * + * RETURN VALUE: + * Upon sucessfully removing the (possibly running) daemon from startup, 0 + * is returned. Otherwise -1 is returned. + * + * NOTES: + * On win32 this does the services thing. + * + * Otherwise, it cooperates with the supplied "backuppc.init" script to + * manage the SKIPSTARTFILE. If this file exists, the "backuppc.init" + * script's start action aborts. backuppcd deletes the file upon sucessful + * startup. This function creates the file and stops the running daemon. + * + */ +static int daemon_remove(void) { + int retval = -1; + int stop_ret; + + stop_ret = daemon_stop(); + + if (stop_ret < 0) { + retval = -1; + } + +#ifndef _USE_WIN32_ + creat(SKIPSTARTFILE, 0600); + retval = 0; +#else + if (manager == NULL) { + manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); + if (manager == NULL) { + fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); + return(-1); + } + } + + service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); + if (service == NULL) { + fprintf(stderr, "Could not open service: %i\n", (int) GetLastError()); + return(-1); + } + + if (!DeleteService(service)) { + fprintf(stderr, "Could not delete service: %i\n", (int) GetLastError()); + return(-1); + } + + fprintf(stderr, "Service deleted.\n"); + + retval = 0; +#endif + return(retval); +} + +/* + * SYNOPSIS: + * static void daemon_start( + * int argc, + * char **argv + * ); + * + * ARGUMENTS: + * int argc Number of arguments + * char *argv Argument data + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static void daemon_start(int argc, char **argv) { +#ifdef _USE_WIN32_ + /* Create a Win32 Service. */ + /* Most of this was taken from "tinc" (src/process.c) */ +#ifdef NO_WIN32_NT4 + /* Windows NT 4.0 lacks the `ChangeServiceConfig2' call. */ + SERVICE_DESCRIPTION description = {"BackupPC Client Daemon"}; +#endif + char svcCommand[8192], *svcptr; + int argind; + + /* + * This whole mess is to construct the "lpBinaryPathName" which needs + * quotes and all kinds of other non-sense. + */ + svcptr = svcCommand; + + strcpy(svcptr, "\""); + svcptr += strlen(svcptr); /* This is not the same as svcptr++. */ + + /* If the full path wasn't specified, assume it's in the current directory. */ + if (strchr(argv[0], '\\') == NULL) { + GetCurrentDirectory(sizeof(svcCommand) - (svcptr - svcCommand) - 1, svcptr); + svcptr += strlen(svcptr); + strncat(svcptr, "\\", sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + } + strncat(svcptr, argv[0], sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + strncat(svcptr, "\"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + + for (argind = 1; argind < argc; argind++) { + strncat(svcptr, " \"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + + strncat(svcptr, argv[argind], sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + + strncat(svcptr, "\"", sizeof(svcCommand) - (svcptr - svcCommand) - 1); + svcptr += strlen(svcptr); + } + + manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); + if (manager == NULL) { + fprintf(stderr, "Could not contact service manager: %i\n", (int) GetLastError()); + exit(EXIT_FAILURE); + } + + /* + * This will ultimately spawn another set of processes so we may exit. + */ + service = CreateService(manager, svcName, svcName, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, svcCommand, "NDIS", NULL, NULL, NULL, NULL); + + if (service == NULL) { + if (GetLastError() == ERROR_SERVICE_EXISTS) { + service = OpenService(manager, svcName, SERVICE_ALL_ACCESS); + } + + if (service == NULL) { + fprintf(stderr, "Could not create service: %i\n", (int) GetLastError()); + exit(EXIT_FAILURE); + } + } + +#ifdef NO_WIN32_NT4 + /* Windows NT 4.0 lacks this call. */ + ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &description); +#endif + + if (!StartService(service, 0, NULL)) { + fprintf(stderr, "Could not start service: %i\n", (int) GetLastError()); + exit(EXIT_FAILURE); + } else { + printf("Service started.\n"); + } + + + exit(EXIT_SUCCESS); +#endif + return; +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ); + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_opt_remove_svc(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { + if (daemon_remove() < 0) { + exit(EXIT_FAILURE); + } + + exit(EXIT_SUCCESS); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +static int backuppc_opt_stop_svc(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { + if (daemon_stop() < 0) { + exit(EXIT_FAILURE); + } + + exit(EXIT_SUCCESS); +} + +static int backuppc_opt_showvers(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { + printf("%s\n", PACKAGE_VERSION); + exit(EXIT_SUCCESS); +} + +static int backuppc_opt_prio(const char *shortvar, const char *var, const char *arguments, const char *value, lc_flags_t flags, void *extra) { + char *prio_names[3] = {"min", "max", "normal"}; + int prio_vals[3] = {BPC_PRIO_MIN, BPC_PRIO_MAX, BPC_PRIO_NORM}; + int prio_val = -1; + int i; + + if (!value) { + return(LC_CBRET_ERROR); + } + + if (strlen(value) > 0) { + for (i = 0; i < (sizeof(prio_names) / sizeof(*prio_names)); i++) { + if (strncasecmp(prio_names[i], value, strlen(value)) == 0) { + if (prio_val == -1) { + prio_val = prio_vals[i]; + } else { + fprintf(stderr, "Ambigious priority name: %s, should be Min, Max, or Normal.\n", value); + return(LC_CBRET_ERROR); + } + } + } + } + + if (prio_val == -1) { + fprintf(stderr, "Invalid priority name: %s, should be Min, Max, or Normal.\n", value); + return(LC_CBRET_ERROR); + } + + backuppc_setpriority(prio_val); + + return(LC_CBRET_OKAY); +} + +/* + * SYNOPSIS: + * static void backuppc_pathmangle( + * char *pathname + * ) + * + * ARGUMENTS: + * char *pathname Pathname to mangle. + * + * RETURN VALUE: + * (none) + * + * NOTES: + * + */ +int main(int argc, char *argv[]) { + int lc_p_ret = 0; + char *update_source = NULL, *update_dest = NULL, *update_delefile = NULL; + char *config_file = NULL; + int do_switch = 0; + + /* + * Initialize the authentication subsystem. + * + * It will add its own set of options to the configuration processor + */ + bpcd_auth_init(); + + /* + * Register configuration commands and command line arguments. + */ + lc_register_callback("Remove", 'r', LC_VAR_NONE, backuppc_opt_remove_svc, NULL); + lc_register_callback("Stop", 'k', LC_VAR_NONE, backuppc_opt_stop_svc, NULL); + lc_register_callback("Version", 'V', LC_VAR_NONE, backuppc_opt_showvers, NULL); + lc_register_callback("Priority", 'P', LC_VAR_STRING, backuppc_opt_prio, NULL); + lc_register_var("Port", LC_VAR_INT, &backuppc_port, 'p'); + lc_register_var("UpdateURL", LC_VAR_STRING, &backuppc_updateurl, 'U'); + lc_register_var("Source", LC_VAR_STRING, &update_source, 0); + lc_register_var("Destination", LC_VAR_STRING, &update_dest, 0); + lc_register_var("Switch", LC_VAR_BOOL_BY_EXISTANCE, &do_switch, 0); + lc_register_var("DeleteFile", LC_VAR_STRING, &update_delefile, 0); + lc_register_var("BinaryFile", LC_VAR_STRING, &backuppc_binfile, 0); + lc_register_var("ConfigFile", LC_VAR_STRING, &config_file, 'C'); + lc_register_var("NotifyServer", LC_VAR_STRING, &backuppc_notifyserv, 'S'); + + /* + * Process standard config files, command line arguments, and + * environment variables. + */ + lc_p_ret = lc_process(argc, argv, "backuppcd", LC_CONF_SPACE, SYSCONFDIR "/backuppcd.conf"); + if (lc_p_ret < 0) { + fprintf(stderr, "Error processing configuration information: %s.\n", lc_geterrstr()); + return(EXIT_FAILURE); + } + + /* + * If an alternative config file is specified above, process it. + */ + if (config_file) { + lc_p_ret = lc_process_file("backuppcd", config_file, LC_CONF_SPACE); + + if (lc_p_ret < 0) { + fprintf(stderr, "Error processing configuration information: %s.\n", lc_geterrstr()); + return(EXIT_FAILURE); + } + } + + /* + * Finished with configuration. + */ + lc_cleanup(); + + /* + * If we've been told to delete a file, do so without regard for + * failure. + */ + if (update_delefile) { + unlink(update_delefile); + } + + /* + * Since you can never open a running executable for writing so to + * upgrade ourselves we must: + * a. Download the new version to some temporary location + * b. Call the new version and tell it to replace the old version + * with itself (--Switch argument) + * c. Call the copy + * d. Delete the file from the temporary location + */ + if (do_switch) { + if (update_source == NULL || update_dest == NULL) { + fprintf(stderr, "Error: You must provide a --Source and --Destination to use --Switch\n"); + return(EXIT_FAILURE); + } + + backuppc_switchupdate(update_source, update_dest, argc, argv); + + return(EXIT_SUCCESS); + } + +#ifndef _USE_WIN32_ + /* + * We cannot check for a new version at start-up on Windows because it + * really messes with the "Services" stuff. Bummer, man. + */ + if (backuppc_updateurl) { + backuppc_update(backuppc_updateurl, argc, argv); + } +#endif + + if (backuppc_notifyserv) { + backuppc_notify(backuppc_notifyserv, backuppc_notifyport, NULL); + } + +#ifndef DEBUG + /* + * If daemon initialization went well, we're no longer needed. + */ + if (daemon_init() == DAEMON_RET_SUCCESS) { + return(EXIT_SUCCESS); + } + + daemon_start(argc, argv); +#endif + +#ifdef HAVE_SIGNAL + /* + * We don't care about SIGPIPE, we properly handle read errors. + */ + signal(SIGPIPE, SIG_IGN); +#endif + + /* + * This will be replaced with a proper logging mechanism at some point (XXX) + */ +#ifdef HAVE_OPENLOG + openlog("backuppcd", LOG_PID, LOG_DAEMON); +#endif + + /* + * Begin primary processing. + */ + return(backuppc_loop(argc, argv)); +} diff --git a/backuppcd.conf b/backuppcd.conf new file mode 100644 index 0000000..9befed2 --- /dev/null +++ b/backuppcd.conf @@ -0,0 +1,14 @@ +# +User rkeene 984816fd329622876e14907634264e6f332e9fb3 ReadWrite + +# +Port 874 + +# +WriteBufferSize 32000 + +# +UpdateURL http://www.rkeene.org/projects/rget/backuppcd-@@OSNM@@-@@OSVS@@-@@ARCH@@ + +# Register our existance and name with the following server +NotifyServer BackupPCServer diff --git a/backuppcd.h b/backuppcd.h new file mode 100644 index 0000000..8852e43 --- /dev/null +++ b/backuppcd.h @@ -0,0 +1,156 @@ +#ifndef _BACKUPPCD_H +#define _BACKUPPCD_H 1 +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +/* + * These define the values that we send and recieve over the wire denoting + * what type of file is beiNg referenced. + * + * Must fit inside a uint8_t + */ +typedef enum { + BPC_FILE_DIR = 0, + BPC_FILE_REG = 1, + BPC_FILE_SYMLINK = 2, + BPC_FILE_SOCKET = 3, + BPC_FILE_FIFO = 4, + BPC_FILE_BDEV = 5, + BPC_FILE_CDEV = 6, + BPC_FILE_HRDLINK = 7, + BPC_FILE_UNKNOWN = 255 +} backuppc_filetype_t; + +/* + * These define the values for each command sent and recieved over the wire. + * Reply messages have their high-bit set. + * + * Must fit inside a uint8_t + */ +typedef enum { + BPC_CMD_NONE = 0, + BPC_CMD_AUTH = 1, + BPC_CMD_SSL = 2, + BPC_CMD_KEY = 3, + BPC_CMD_LIST = 4, + BPC_CMD_GET = 5, + BPC_CMD_PUT = 6, + BPC_CMD_RDGET = 7, + BPC_CMD_AUTH_REPLY = (BPC_CMD_AUTH | 0x80), + BPC_CMD_SSL_REPLY = (BPC_CMD_SSL | 0x80), + BPC_CMD_KEY_REPLY = (BPC_CMD_KEY | 0x80), + BPC_CMD_LIST_REPLY = (BPC_CMD_LIST | 0x80), + BPC_CMD_GET_REPLY = (BPC_CMD_GET | 0x80), + BPC_CMD_PUT_REPLY = (BPC_CMD_PUT | 0x80), + BPC_CMD_RDGET_REPLY = (BPC_CMD_RDGET | 0x80), +} backuppc_cmd_t; + +/* + * These define the values we send and recieve over the wire to describe each + * attribute for a referenced file. + * + * Must fit inside a uint16_t + */ +typedef enum { + BPC_ATTRID_NOP = 0, + BPC_ATTRID_MTIME = 1, + BPC_ATTRID_CTIME = 2, + BPC_ATTRID_USER = 3, + BPC_ATTRID_GROUP = 4, + BPC_ATTRID_UID = 5, + BPC_ATTRID_GID = 6, + BPC_ATTRID_MD5 = 7, + BPC_ATTRID_ACL = 8, + BPC_ATTRID_PACL = 9, + BPC_ATTRID_NTACL = 10, + BPC_ATTRID_SYMLINKDEST = 11, + BPC_ATTRID_HRDLINKDEST = 12, + BPC_ATTRID_MD4 = 13, + BPC_ATTRID_SHA1 = 14, + BPC_ATTRID_BPCHASH = 15, +} backuppc_attrid_t; + +/* + * These define the values we send and recieve over the wire to describe the + * hashing algorithm used for RDIFF + * + * Must fit inside a uint8_t + */ +typedef enum { + BPC_HASH_NONE = 0, + BPC_HASH_MD5 = 1, + BPC_HASH_MD4 = 2, + BPC_HASH_SHA1 = 3, + BPC_HASH_BPC = 4, +} backuppc_hashid_t; + +/* + * These are used for short status messages. + * + * Must fit inside a uint8_t + */ +typedef enum { + BPC_STATUS_OKAY = 0, + BPC_STATUS_FAILED = 1, + BPC_STATUS_UNKNOWN = 255 +} backuppc_status_t; + +/* + * These values are used to in the ACL entry for a LIST or GET reply. + * They are the values for an ACL entry. Extended ACLs will be either + * PACL (POSIX ACL) or NTACL (Microsoft NT ACL). + * + * Must fit inside a uint16_t + */ +#define BPC_ACL_XOTH 00001 +#define BPC_ACL_WOTH 00002 +#define BPC_ACL_ROTH 00004 +#define BPC_ACL_XGRP 00010 +#define BPC_ACL_WGRP 00020 +#define BPC_ACL_RGRP 00040 +#define BPC_ACL_XUSR 00100 +#define BPC_ACL_WUSR 00200 +#define BPC_ACL_RUSR 00400 +#define BPC_ACL_STCK 01000 +#define BPC_ACL_SGID 02000 +#define BPC_ACL_SUID 04000 + +/* + * These values are used for the OPTIONS field in a LIST or GET request. + * They may be combined. + * + * Must fit inside a uint8_t when ORd together. + */ +#define BPC_OPT_RECURSIVE 0x01 +#define BPC_OPT_MD5 0x02 +#define BPC_OPT_MD4 0x04 +#define BPC_OPT_SHA1 0x08 +#define BPC_OPT_BPCHASH 0x10 + +/* + * Maximum pathname length to support. + */ +#define BPC_MAXPATH_LEN 4096 + +#endif diff --git a/chown.c b/chown.c new file mode 100644 index 0000000..461767e --- /dev/null +++ b/chown.c @@ -0,0 +1,9 @@ +#include "chown.h" + +#ifndef HAVE_CHOWN + +int chown(const char *path, uint32_t owner, uint32_t group) { + return(-1); +} + +#endif diff --git a/chown.h b/chown.h new file mode 100644 index 0000000..5eea4d4 --- /dev/null +++ b/chown.h @@ -0,0 +1,12 @@ +#include "compat.h" +#include "backuppcd.h" +#include "backuppcd-common.h" + +#ifndef HAVE_CHOWN +# ifndef _RSK_CHOWN_H +# define _RSK_CHOWN_H 1 + +int chown(const char *path, uint32_t owner, uint32_t group); + +# endif /* _RSK_CHOWN_H */ +#endif /* HAVE_CHOWN */ diff --git a/compat.h b/compat.h new file mode 100644 index 0000000..732b165 --- /dev/null +++ b/compat.h @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + + +#ifndef RSK_COMPAT_H +#define RSK_COMPAT_H + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#ifdef __WIN32__ +#include "win32.h" +#endif + +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_MEMORY_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_STRINGS_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif +#ifdef HAVE_SYS_STAT_H +#include +#endif +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_ERRNO_H +#include +#endif +#ifdef HAVE_FCNTL_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_STDARG_H +#include +#endif +#ifdef HAVE_STDIO_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_SYS_STATFS_H +#include +#else +#ifdef HAVE_SYS_VFS_H +#include +#endif +#endif +#ifdef HAVE_SYS_RESOURCE_H +#include +#endif +#ifdef TIME_WITH_SYS_TIME +#include +#include +#else +#ifdef HAVE_SYS_TIME_H +#include +#else +#include +#endif +#endif + +#ifndef HAVE_SOCKLEN_T +#ifdef NEED_SOCKLEN_T +typedef int socklen_t; +#endif +#endif + +#ifndef HAVE_HTONLL +#include "htonll.h" +#endif + +#ifndef HAVE_NTOHLL +#include "ntohll.h" +#endif + +#ifndef HAVE_STRSEP +#include "strsep.h" +#endif + +#ifndef HAVE_GETHOSTNAME +#include "gethostname.h" +#endif + +#ifdef HAVE_STATFS +/* + * These constants are used to determine the filesystem type from statfs(). + * Only used under Linux as other statfs() implementations return ftype == 0. + */ +#ifndef NFS_SUPER_MAGIC +#define NFS_SUPER_MAGIC 0x6969 +#endif +#ifndef PROC_SUPER_MAGIC +#define PROC_SUPER_MAGIC 0x9fa0 +#endif +#ifndef DEVFS_SUPER_MAGIC +#define DEVFS_SUPER_MAGIC 0x1373 +#endif +#ifndef ISOFS_SUPER_MAGIC +#define ISOFS_SUPER_MAGIC 0x9660 +#endif +#ifndef NCP_SUPER_MAGIC +#define NCP_SUPER_MAGIC 0x564c +#endif +#ifndef SMB_SUPER_MAGIC +#define SMB_SUPER_MAGIC 0x517B +#endif +#ifndef TMPFS_MAGIC +#define TMPFS_MAGIC 0x01021994 +#endif +#endif + + + +#ifdef DEBUG +#define PRINT_LINE fprintf(stderr, "%lu:%s:%i:%s(): ", (unsigned long) time(NULL), __FILE__, __LINE__, __func__); +#define PRINTERR_D(x...) { PRINT_LINE; fprintf(stderr, x); fprintf(stderr, "\n"); } +#define PERROR(x) { PRINT_LINE; perror(x); } +#define DPERROR(x) PERROR(x) +#define DPRINTF(x...) { PRINT_LINE; fprintf(stderr, x); fprintf(stderr, "\n"); } +#else +#define PRINT_LINE /**/ +#define PRINTERR_D(x...) /**/ +#define PERROR(x) perror(x); +#define DPERROR(x) /**/ +#endif +#define CHECKPOINT PRINTERR_D("*** CHECKPOINT REACHED ***") +#define SPOTVAR_LLX(x) PRINTERR_D(#x " = %llx", (unsigned long long) x) +#define SPOTVAR_LLU(x) PRINTERR_D(#x " = %llu", (unsigned long long) x) +#define SPOTVAR_LU(x) PRINTERR_D(#x " = %lu", (unsigned long) x) +#define SPOTVAR_D(x) PRINTERR_D(#x " = %lf", x) +#define SPOTVAR_X(x) PRINTERR_D(#x " = 0x%x", (unsigned int) x) +#define SPOTVAR_I(x) PRINTERR_D(#x " = %i", (int) x) +#define SPOTVAR_P(x) PRINTERR_D(#x " = %p", x) +#define SPOTVAR_S(x) PRINTERR_D(#x " = \"%s\"", x) +#define PRINTERR(x...) { PRINT_LINE; fprintf(stderr, x); fprintf(stderr, "\n"); fflush(stderr); } +#define LOG(x...) { PRINT_LINE; fprintf(stderr, "LOG: " x); fprintf(stderr, "\n"); } + +#endif diff --git a/config.guess b/config.guess new file mode 100755 index 0000000..51fab47 --- /dev/null +++ b/config.guess @@ -0,0 +1,1459 @@ +#! /bin/sh +# Attempt to guess a canonical system name. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + +timestamp='2004-03-12' + +# This file 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. +# +# 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. + +# Originally written by Per Bothner . +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# This script attempts to guess a canonical system name similar to +# config.sub. If it succeeds, it prints the system name on stdout, and +# exits with 0. Otherwise, it exits with 1. +# +# The plan is that this can be called by configure scripts if you +# don't specify an explicit build system type. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep __ELF__ >/dev/null + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit 0 ;; + amd64:OpenBSD:*:*) + echo x86_64-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + amiga:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + arc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + cats:OpenBSD:*:*) + echo arm-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + hp300:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mac68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + macppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme68k:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvme88k:OpenBSD:*:*) + echo m88k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + mvmeppc:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + pegasos:OpenBSD:*:*) + echo powerpc-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + pmax:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sgi:OpenBSD:*:*) + echo mipseb-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + sun3:OpenBSD:*:*) + echo m68k-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + wgrisc:OpenBSD:*:*) + echo mipsel-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + *:OpenBSD:*:*) + echo ${UNAME_MACHINE}-unknown-openbsd${UNAME_RELEASE} + exit 0 ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit 0 ;; + macppc:MirBSD:*:*) + echo powerppc-unknown-mirbsd${UNAME_RELEASE} + exit 0 ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit 0 ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + exit 0 ;; + Alpha*:OpenVMS:*:*) + echo alpha-hp-vms + exit 0 ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit 0 ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit 0 ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit 0;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit 0 ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit 0 ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit 0 ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit 0 ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit 0;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit 0;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit 0 ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit 0 ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit 0 ;; + DRS?6000:UNIX_SV:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7 && exit 0 ;; + esac ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + i86pc:SunOS:5.*:*) + echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit 0 ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit 0 ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit 0 ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit 0 ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit 0 ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit 0 ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit 0 ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit 0 ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit 0 ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit 0 ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit 0 ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit 0 ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit 0 ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c \ + && $dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \ + && exit 0 + echo mips-mips-riscos${UNAME_RELEASE} + exit 0 ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit 0 ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit 0 ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit 0 ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit 0 ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit 0 ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit 0 ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit 0 ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit 0 ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit 0 ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit 0 ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit 0 ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit 0 ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit 0 ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit 0 ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo rs6000-ibm-aix3.2.5 + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit 0 ;; + *:AIX:*:[45]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit 0 ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit 0 ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit 0 ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit 0 ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit 0 ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit 0 ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit 0 ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit 0 ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + # avoid double evaluation of $set_cc_for_build + test -n "$CC_FOR_BUILD" || eval $set_cc_for_build + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E -) | grep __LP64__ >/dev/null + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit 0 ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit 0 ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && $dummy && exit 0 + echo unknown-hitachi-hiuxwe2 + exit 0 ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit 0 ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit 0 ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit 0 ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit 0 ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit 0 ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit 0 ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit 0 ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit 0 ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit 0 ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit 0 ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit 0 ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + *:UNICOS/mp:*:*) + echo nv1-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit 0 ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit 0 ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit 0 ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit 0 ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit 0 ;; + *:FreeBSD:*:*) + # Determine whether the default compiler uses glibc. + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #if __GLIBC__ >= 2 + LIBC=gnu + #else + LIBC= + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + # GNU/KFreeBSD systems have a "k" prefix to indicate we are using + # FreeBSD's kernel, but not the complete OS. + case ${LIBC} in gnu) kernel_only='k' ;; esac + echo ${UNAME_MACHINE}-unknown-${kernel_only}freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`${LIBC:+-$LIBC} + exit 0 ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit 0 ;; + i*:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit 0 ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit 0 ;; + x86:Interix*:[34]*) + echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//' + exit 0 ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit 0 ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit 0 ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit 0 ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit 0 ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit 0 ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit 0 ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu + exit 0 ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit 0 ;; + arm*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + cris:Linux:*:*) + echo cris-axis-linux-gnu + exit 0 ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + mips:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips + #undef mipsel + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mipsel + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef mips64 + #undef mips64el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=mips64el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=mips64 + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=` + test x"${CPU}" != x && echo "${CPU}-unknown-linux-gnu" && exit 0 + ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-gnu + exit 0 ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-gnu + exit 0 ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null + if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi + echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} + exit 0 ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-gnu ;; + PA8*) echo hppa2.0-unknown-linux-gnu ;; + *) echo hppa-unknown-linux-gnu ;; + esac + exit 0 ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-gnu + exit 0 ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux + exit 0 ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-gnu + exit 0 ;; + x86_64:Linux:*:*) + echo x86_64-unknown-linux-gnu + exit 0 ;; + i*86:Linux:*:*) + # The BFD linker knows what the default object file format is, so + # first see if it will tell us. cd to the root directory to prevent + # problems with other programs or directories called `ld' in the path. + # Set LC_ALL=C to ensure ld outputs messages in English. + ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \ + | sed -ne '/supported targets:/!d + s/[ ][ ]*/ /g + s/.*supported targets: *// + s/ .*// + p'` + case "$ld_supported_targets" in + elf32-i386) + TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu" + ;; + a.out-i386-linux) + echo "${UNAME_MACHINE}-pc-linux-gnuaout" + exit 0 ;; + coff-i386) + echo "${UNAME_MACHINE}-pc-linux-gnucoff" + exit 0 ;; + "") + # Either a pre-BFD a.out linker (linux-gnuoldld) or + # one that does not give us useful --help. + echo "${UNAME_MACHINE}-pc-linux-gnuoldld" + exit 0 ;; + esac + # Determine whether the default compiler is a.out or elf + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + #ifdef __ELF__ + # ifdef __GLIBC__ + # if __GLIBC__ >= 2 + LIBC=gnu + # else + LIBC=gnulibc1 + # endif + # else + LIBC=gnulibc1 + # endif + #else + #ifdef __INTEL_COMPILER + LIBC=gnu + #else + LIBC=gnuaout + #endif + #endif + #ifdef __dietlibc__ + LIBC=dietlibc + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=` + test x"${LIBC}" != x && echo "${UNAME_MACHINE}-pc-linux-${LIBC}" && exit 0 + test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0 + ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit 0 ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit 0 ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit 0 ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit 0 ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit 0 ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit 0 ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit 0 ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit 0 ;; + i*86:*:5:[78]*) + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit 0 ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit 0 ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i386. + echo i386-pc-msdosdjgpp + exit 0 ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit 0 ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit 0 ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit 0 ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit 0 ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit 0 ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit 0 ;; + M68*:*:R3V[567]*:*) + test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4.3${OS_REL} && exit 0 + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && echo i486-ncr-sysv4 && exit 0 ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit 0 ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit 0 ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit 0 ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit 0 ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit 0 ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit 0 ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit 0 ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit 0 ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit 0 ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit 0 ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit 0 ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit 0 ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit 0 ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit 0 ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit 0 ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit 0 ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit 0 ;; + *:Darwin:*:*) + case `uname -p` in + *86) UNAME_PROCESSOR=i686 ;; + powerpc) UNAME_PROCESSOR=powerpc ;; + esac + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit 0 ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit 0 ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit 0 ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit 0 ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit 0 ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit 0 ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit 0 ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit 0 ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit 0 ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit 0 ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit 0 ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit 0 ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit 0 ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit 0 ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit 0 ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit 0 ;; +esac + +#echo '(No uname command or uname output not recognized.)' 1>&2 +#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 + +eval $set_cc_for_build +cat >$dummy.c < +# include +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (__arm) && defined (__acorn) && defined (__unix) + printf ("arm-acorn-riscix"); exit (0); +#endif + +#if defined (hp300) && !defined (hpux) + printf ("m68k-hp-bsd\n"); exit (0); +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); + +#endif + +#if defined (vax) +# if !defined (ultrix) +# include +# if defined (BSD) +# if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +# else +# if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# endif +# else + printf ("vax-dec-bsd\n"); exit (0); +# endif +# else + printf ("vax-dec-ultrix\n"); exit (0); +# endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && $dummy && exit 0 + +# Apollos put the system type in the environment. + +test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; } + +# Convex versions that predate uname can use getsysinfo(1) + +if [ -x /usr/convex/getsysinfo ] +then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit 0 ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + c34*) + echo c34-convex-bsd + exit 0 ;; + c38*) + echo c38-convex-bsd + exit 0 ;; + c4*) + echo c4-convex-bsd + exit 0 ;; + esac +fi + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/config.h.in b/config.h.in new file mode 100644 index 0000000..f300868 --- /dev/null +++ b/config.h.in @@ -0,0 +1,341 @@ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to the master password */ +#undef BPC_CONF_MASTER_PASSWORD + +/* Define to the server to send host notifications to */ +#undef BPC_CONF_NOTIFYSERV + +/* Define to the URL to update against */ +#undef BPC_CONF_UPDATEURL + +/* Define if you wish to enable debugging support */ +#undef DEBUG + +/* Define this to 1 if you do not know what endian-ness your platform is. */ +#undef ENDIAN_UNKNOWN + +/* Define to 1 if you have the header file. */ +#undef HAVE_ARPA_INET_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_ASSERT_H + +/* Define to 1 if you have the `chown' function. */ +#undef HAVE_CHOWN + +/* Define to 1 if you have the header file. */ +#undef HAVE_CTYPE_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_DIRENT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_ENDIAN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_ERRNO_H + +/* Define to 1 if you have the `fcntl' function. */ +#undef HAVE_FCNTL + +/* Define to 1 if you have the header file. */ +#undef HAVE_FCNTL_H + +/* Define to 1 if you have the `fnmatch' function. */ +#undef HAVE_FNMATCH + +/* Define to 1 if you have the header file. */ +#undef HAVE_FNMATCH_H + +/* Define to 1 if you have the `fork' function. */ +#undef HAVE_FORK + +/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */ +#undef HAVE_FSEEKO + +/* Define to 1 if you have the `getenv' function. */ +#undef HAVE_GETENV + +/* Define to 1 if you have the `gethostname' function. */ +#undef HAVE_GETHOSTNAME + +/* Define to 1 if you have the `getmntinfo' function. */ +#undef HAVE_GETMNTINFO + +/* Define to 1 if you have the `htonll' function. */ +#undef HAVE_HTONLL + +/* Have inet_addr() */ +#undef HAVE_INET_ADDR + +/* Have inet_aton() */ +#undef HAVE_INET_ATON + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the `lchown' function. */ +#undef HAVE_LCHOWN + +/* Define to 1 if you have lc_process from libconfig */ +#undef HAVE_LIBCONFIG + +/* Define to 1 if you have the header file. */ +#undef HAVE_LIBCONFIG_H + +/* Define to 1 if you have fopen_net from opennet */ +#undef HAVE_LIBOPENNET + +/* Define to 1 if you have SSL_library_init from openssl */ +#undef HAVE_LIBSSL + +/* Have libwsock32 */ +#undef HAVE_LIBWSOCK32 + +/* Define to 1 if you have the header file. */ +#undef HAVE_LIMITS_H + +/* Define to 1 if you have the `link' function. */ +#undef HAVE_LINK + +/* Define to 1 if you have the `lstat' function. */ +#undef HAVE_LSTAT + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_NETDB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_NETINET_IN_H + +/* Define to 1 if you have the `ntohll' function. */ +#undef HAVE_NTOHLL + +/* Define to 1 if you have the `openlog' function. */ +#undef HAVE_OPENLOG + +/* Define to 1 if you have the header file. */ +#undef HAVE_OPENNET_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_OPENSSL_SSL_H + +/* Define to 1 if you have the `readlink' function. */ +#undef HAVE_READLINK + +/* Define to 1 if you have the `setpriority' function. */ +#undef HAVE_SETPRIORITY + +/* Define to 1 if you have the `setsid' function. */ +#undef HAVE_SETSID + +/* Define to 1 if you have the `signal' function. */ +#undef HAVE_SIGNAL + +/* Define to 1 if you have the header file. */ +#undef HAVE_SIGNAL_H + +/* Define to 1 if you have the "socklen_t" type. */ +#undef HAVE_SOCKLEN_T + +/* Define to 1 if you have the header file. */ +#undef HAVE_SSL_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SSL_SSL_H + +/* Define to 1 if you have the `stat' function. */ +#undef HAVE_STAT + +/* Define to 1 if you have the `statfs' function. */ +#undef HAVE_STATFS + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDARG_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDIO_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the `strsep' function. */ +#undef HAVE_STRSEP + +/* Define to 1 if you have the `symlink' function. */ +#undef HAVE_SYMLINK + +/* Define to 1 if you have the `sysinfo' function. */ +#undef HAVE_SYSINFO + +/* Define to 1 if you have the `syslog' function. */ +#undef HAVE_SYSLOG + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYSLOG_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_MOUNT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_PARAM_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_RESOURCE_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_SELECT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_SOCKET_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STATFS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIME_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_VFS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_TIME_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Define to 1 if you have the `utime' function. */ +#undef HAVE_UTIME + +/* Define to 1 if you have the header file. */ +#undef HAVE_UTIME_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_WINDOWSX_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_WINDOWS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_WINSOCK2_H + +/* Define if you wish to disable debugging support */ +#undef NDEBUG + +/* Define to 1 if you need the "socklen_t" type. */ +#undef NEED_SOCKLEN_T + +/* Define if you wish to disallow support for Windows NT 4 */ +#undef NO_WIN32_NT4 + +/* 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 + +/* The size of a `int', as computed by sizeof. */ +#undef SIZEOF_INT + +/* The size of a `long', as computed by sizeof. */ +#undef SIZEOF_LONG + +/* The size of a `long long', as computed by sizeof. */ +#undef SIZEOF_LONG_LONG + +/* The size of a `short', as computed by sizeof. */ +#undef SIZEOF_SHORT + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Define to 1 if you have the <> header file. */ +#undef THIS_MAKES_STUPID_AUTOHEADER_HAPPY + +/* Define to 1 if you can safely include both and . */ +#undef TIME_WITH_SYS_TIME + +/* Define to 1 if your processor stores words with the most significant byte + first (like Motorola and SPARC, unlike Intel and VAX). */ +#undef WORDS_BIGENDIAN + +/* Define to 1 if on AIX 3. + System headers sometimes define this. + We just want to avoid a redefinition error message. */ +#ifndef _ALL_SOURCE +# undef _ALL_SOURCE +#endif + +/* Number of bits in a file offset, on hosts where this is settable. */ +#undef _FILE_OFFSET_BITS + +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# undef _GNU_SOURCE +#endif + +/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */ +#undef _LARGEFILE_SOURCE + +/* Define for large files, on AIX-style hosts. */ +#undef _LARGE_FILES + +/* Define to `int' if doesn't define. */ +#undef gid_t + +/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#ifndef __cplusplus +#undef inline +#endif + +/* Define to `signed short' if does not define. */ +#undef int16_t + +/* Define to `signed short' if does not define. */ +#undef int32_t + +/* Define to `signed short' if does not define. */ +#undef int64_t + +/* Define to `long' if does not define. */ +#undef off_t + +/* Define to `int' if doesn't define. */ +#undef uid_t + +/* Define to `unsigned short' if does not define. */ +#undef uint16_t + +/* Define to `unsigned short' if does not define. */ +#undef uint32_t + +/* Define to `unsigned short' if does not define. */ +#undef uint64_t diff --git a/config.sub b/config.sub new file mode 100755 index 0000000..ba33103 --- /dev/null +++ b/config.sub @@ -0,0 +1,1549 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, +# 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + +timestamp='2004-03-12' + +# This file is (in principle) common to ALL GNU software. +# The presence of a machine in this file suggests that SOME GNU software +# can handle that machine. It does not imply ALL GNU software can. +# +# This file 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. + +# 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. + +# Please send patches to . Submit a context +# diff and a properly formatted ChangeLog entry. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 +Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit 0 ;; + --version | -v ) + echo "$version" ; exit 0 ;; + --help | --h* | -h ) + echo "$usage"; exit 0 ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit 0;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | linux-dietlibc | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | \ + kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis) + os= + basic_machine=$1 + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \ + | c4x | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | m32r | m32rle | m68000 | m68k | m88k | mcore \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64vr | mips64vrel \ + | mips64orion | mips64orionel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | msp430 \ + | ns16k | ns32k \ + | openrisc | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ + | pyramid \ + | sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv8 | sparcv9 | sparcv9b \ + | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ + | v850 | v850e \ + | we32k \ + | x86 | xscale | xstormy16 | xtensa \ + | z8k) + basic_machine=$basic_machine-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12) + # Motorola 68HC11/12. + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* \ + | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ + | clipper-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | m32r-* | m32rle-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | mcore-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64r2-* | mipsisa64r2el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipstx39-* | mipstx39el-* \ + | msp430-* \ + | none-* | np1-* | nv1-* | ns16k-* | ns32k-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ + | pyramid-* \ + | romp-* | rs6000-* \ + | sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \ + | tahoe-* | thumb-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tron-* \ + | v850-* | v850e-* | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \ + | xtensa-* \ + | ymp-* \ + | z8k-*) + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + abacus) + basic_machine=abacus-unknown + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amd64-*) + basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + cr16c) + basic_machine=cr16c-unknown + os=-elf + ;; + crds | unos) + basic_machine=m68k-crds + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + crx) + basic_machine=crx-unknown + os=-elf + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; +# I'm not sure what "Sysv32" means. Should this be sysv3.2? + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + mingw32) + basic_machine=i386-pc + os=-mingw32 + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + mmix*) + basic_machine=mmix-knuth + os=-mmixware + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + nv1) + basic_machine=nv1-cray + os=-unicosmp + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + or32 | or32-*) + basic_machine=or32-unknown + os=-coff + ;; + os400) + basic_machine=powerpc-ibm + os=-os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc) basic_machine=powerpc-unknown + ;; + ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tic54x | c54x*) + basic_machine=tic54x-unknown + os=-coff + ;; + tic55x | c55x*) + basic_machine=tic55x-unknown + os=-coff + ;; + tic6x | c6x*) + basic_machine=tic6x-unknown + os=-coff + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + tpf) + basic_machine=s390x-ibm + os=-tpf + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh3 | sh4 | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparc | sparcv8 | sparcv9 | sparcv9b) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* | -openbsd* \ + | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ + | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* \ + | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -linux-gnu* | -linux-uclibc* | -uxpv* | -beos* | -mpeix* | -udk* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux-dietlibc) + os=-linux-dietlibc + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -os400*) + os=-os400 + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -syllable*) + os=-syllable + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -tpf*) + os=-tpf + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -kaos*) + os=-kaos + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + # This also exists in the configure program, but was not the + # default. + # os=-sunos4 + ;; + m68*-cisco) + os=-aout + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-ibm) + os=-aix + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -os400*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -tpf*) + vendor=ibm + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit 0 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/configure b/configure new file mode 100755 index 0000000..b184c9a --- /dev/null +++ b/configure @@ -0,0 +1,22060 @@ +#! /bin/sh +# From configure.ac Revision . +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.59 for backuppcd 0.1.3. +# +# Copyright (C) 2003 Free Software Foundation, Inc. +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## --------------------- ## +## M4sh Initialization. ## +## --------------------- ## + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' +elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then + set -o posix +fi +DUALCASE=1; export DUALCASE # for MKS sh + +# Support unset when possible. +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + as_unset=unset +else + as_unset=false +fi + + +# Work around bugs in pre-3.0 UWIN ksh. +$as_unset ENV MAIL MAILPATH +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +for as_var in \ + LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ + LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ + LC_TELEPHONE LC_TIME +do + if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then + eval $as_var=C; export $as_var + else + $as_unset $as_var + fi +done + +# Required to use basename. +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + + +# Name of the executable. +as_me=`$as_basename "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)$' \| \ + . : '\(.\)' 2>/dev/null || +echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } + /^X\/\(\/\/\)$/{ s//\1/; q; } + /^X\/\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + + +# PATH needs CR, and LINENO needs CR and PATH. +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + echo "#! /bin/sh" >conf$$.sh + echo "exit 0" >>conf$$.sh + chmod +x conf$$.sh + if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then + PATH_SEPARATOR=';' + else + PATH_SEPARATOR=: + fi + rm -f conf$$.sh +fi + + + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" || { + # Find who we are. Look in the path if we contain no path at all + # relative or not. + case $0 in + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break +done + + ;; + esac + # We did not find ourselves, most probably we were run as `sh COMMAND' + # in which case we are not to be found in the path. + if test "x$as_myself" = x; then + as_myself=$0 + fi + if test ! -f "$as_myself"; then + { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2 + { (exit 1); exit 1; }; } + fi + case $CONFIG_SHELL in + '') + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for as_base in sh bash ksh sh5; do + case $as_dir in + /*) + if ("$as_dir/$as_base" -c ' + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then + $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } + $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } + CONFIG_SHELL=$as_dir/$as_base + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$0" ${1+"$@"} + fi;; + esac + done +done +;; + esac + + # Create $as_me.lineno as a copy of $as_myself, but with $LINENO + # uniformly replaced by the line number. The first 'sed' inserts a + # line-number line before each line; the second 'sed' does the real + # work. The second script uses 'N' to pair each line-number line + # with the numbered line, and appends trailing '-' during + # substitution so that $LINENO is not a special case at line end. + # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the + # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) + sed '=' <$as_myself | + sed ' + N + s,$,-, + : loop + s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, + t loop + s,-$,, + s,^['$as_cr_digits']*\n,, + ' >$as_me.lineno && + chmod +x $as_me.lineno || + { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 + { (exit 1); exit 1; }; } + + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensible to this). + . ./$as_me.lineno + # Exit status is that of the last command. + exit +} + + +case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in + *c*,-n*) ECHO_N= ECHO_C=' +' ECHO_T=' ' ;; + *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; + *) ECHO_N= ECHO_C='\c' ECHO_T= ;; +esac + +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +rm -f conf$$ conf$$.exe conf$$.file +echo >conf$$.file +if ln -s conf$$.file conf$$ 2>/dev/null; then + # We could just check for DJGPP; but this test a) works b) is more generic + # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). + if test -f conf$$.exe; then + # Don't use ln at all; we don't have any links + as_ln_s='cp -p' + else + as_ln_s='ln -s' + fi +elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.file + +if mkdir -p . 2>/dev/null; then + as_mkdir_p=: +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_executable_p="test -f" + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +# IFS +# We need space, tab and new line, in precisely that order. +as_nl=' +' +IFS=" $as_nl" + +# CDPATH. +$as_unset CDPATH + + +# Name of the host. +# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +exec 6>&1 + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_config_libobj_dir=. +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= +SHELL=${CONFIG_SHELL-/bin/sh} + +# Maximum number of lines to put in a shell here document. +# This variable seems obsolete. It should probably be removed, and +# only ac_max_sed_lines should be used. +: ${ac_max_here_lines=38} + +# Identity of this package. +PACKAGE_NAME='backuppcd' +PACKAGE_TARNAME='backuppcd' +PACKAGE_VERSION='0.1.3' +PACKAGE_STRING='backuppcd 0.1.3' +PACKAGE_BUGREPORT='' + +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#if HAVE_SYS_TYPES_H +# include +#endif +#if HAVE_SYS_STAT_H +# include +#endif +#if STDC_HEADERS +# include +# include +#else +# if HAVE_STDLIB_H +# include +# endif +#endif +#if HAVE_STRING_H +# if !STDC_HEADERS && HAVE_MEMORY_H +# include +# endif +# include +#endif +#if HAVE_STRINGS_H +# include +#endif +#if HAVE_INTTYPES_H +# include +#else +# if HAVE_STDINT_H +# include +# endif +#endif +#if HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os CFLAGS CPPFLAGS AREXT CC LDFLAGS ac_ct_CC EXEEXT OBJEXT SET_MAKE INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA RANLIB ac_ct_RANLIB CPP EGREP AR ac_ct_AR LIBOBJS LTLIBOBJS' +ac_subst_files='' + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datadir='${prefix}/share' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +libdir='${exec_prefix}/lib' +includedir='${prefix}/include' +oldincludedir='/usr/include' +infodir='${prefix}/info' +mandir='${prefix}/man' + +ac_prev= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval "$ac_prev=\$ac_option" + ac_prev= + continue + fi + + ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_option in + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad | --data | --dat | --da) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ + | --da=*) + datadir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid feature name: $ac_feature" >&2 + { (exit 1); exit 1; }; } + ac_feature=`echo $ac_feature | sed 's/-/_/g'` + eval "enable_$ac_feature=no" ;; + + -enable-* | --enable-*) + ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid feature name: $ac_feature" >&2 + { (exit 1); exit 1; }; } + ac_feature=`echo $ac_feature | sed 's/-/_/g'` + case $ac_option in + *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; + *) ac_optarg=yes ;; + esac + eval "enable_$ac_feature='$ac_optarg'" ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst \ + | --locals | --local | --loca | --loc | --lo) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* \ + | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid package name: $ac_package" >&2 + { (exit 1); exit 1; }; } + ac_package=`echo $ac_package| sed 's/-/_/g'` + case $ac_option in + *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; + *) ac_optarg=yes ;; + esac + eval "with_$ac_package='$ac_optarg'" ;; + + -without-* | --without-*) + ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid package name: $ac_package" >&2 + { (exit 1); exit 1; }; } + ac_package=`echo $ac_package | sed 's/-/_/g'` + eval "with_$ac_package=no" ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) { echo "$as_me: error: unrecognized option: $ac_option +Try \`$0 --help' for more information." >&2 + { (exit 1); exit 1; }; } + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && + { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 + { (exit 1); exit 1; }; } + ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` + eval "$ac_envvar='$ac_optarg'" + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + { echo "$as_me: error: missing argument to $ac_option" >&2 + { (exit 1); exit 1; }; } +fi + +# Be sure to have absolute paths. +for ac_var in exec_prefix prefix +do + eval ac_val=$`echo $ac_var` + case $ac_val in + [\\/$]* | ?:[\\/]* | NONE | '' ) ;; + *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 + { (exit 1); exit 1; }; };; + esac +done + +# Be sure to have absolute paths. +for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ + localstatedir libdir includedir oldincludedir infodir mandir +do + eval ac_val=$`echo $ac_var` + case $ac_val in + [\\/$]* | ?:[\\/]* ) ;; + *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 + { (exit 1); exit 1; }; };; + esac +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. + If a cross compiler is detected then cross compile mode will be used." >&2 + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then its parent. + ac_confdir=`(dirname "$0") 2>/dev/null || +$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$0" : 'X\(//\)[^/]' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$0" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r $srcdir/$ac_unique_file; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r $srcdir/$ac_unique_file; then + if test "$ac_srcdir_defaulted" = yes; then + { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2 + { (exit 1); exit 1; }; } + else + { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 + { (exit 1); exit 1; }; } + fi +fi +(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null || + { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2 + { (exit 1); exit 1; }; } +srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` +ac_env_build_alias_set=${build_alias+set} +ac_env_build_alias_value=$build_alias +ac_cv_env_build_alias_set=${build_alias+set} +ac_cv_env_build_alias_value=$build_alias +ac_env_host_alias_set=${host_alias+set} +ac_env_host_alias_value=$host_alias +ac_cv_env_host_alias_set=${host_alias+set} +ac_cv_env_host_alias_value=$host_alias +ac_env_target_alias_set=${target_alias+set} +ac_env_target_alias_value=$target_alias +ac_cv_env_target_alias_set=${target_alias+set} +ac_cv_env_target_alias_value=$target_alias +ac_env_CC_set=${CC+set} +ac_env_CC_value=$CC +ac_cv_env_CC_set=${CC+set} +ac_cv_env_CC_value=$CC +ac_env_CFLAGS_set=${CFLAGS+set} +ac_env_CFLAGS_value=$CFLAGS +ac_cv_env_CFLAGS_set=${CFLAGS+set} +ac_cv_env_CFLAGS_value=$CFLAGS +ac_env_LDFLAGS_set=${LDFLAGS+set} +ac_env_LDFLAGS_value=$LDFLAGS +ac_cv_env_LDFLAGS_set=${LDFLAGS+set} +ac_cv_env_LDFLAGS_value=$LDFLAGS +ac_env_CPPFLAGS_set=${CPPFLAGS+set} +ac_env_CPPFLAGS_value=$CPPFLAGS +ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set} +ac_cv_env_CPPFLAGS_value=$CPPFLAGS +ac_env_CPP_set=${CPP+set} +ac_env_CPP_value=$CPP +ac_cv_env_CPP_set=${CPP+set} +ac_cv_env_CPP_value=$CPP + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures backuppcd 0.1.3 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +_ACEOF + + cat <<_ACEOF +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --datadir=DIR read-only architecture-independent data [PREFIX/share] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --infodir=DIR info documentation [PREFIX/info] + --mandir=DIR man documentation [PREFIX/man] +_ACEOF + + cat <<\_ACEOF + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of backuppcd 0.1.3:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --disable-largefile omit support for large files + --enable-debug Enable debugging support. + --enable-static Enable (mostly) static build. + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-opennet Support opennet (required for automatic updates) + --with-libconfig Process configuration files using libconfig + --with-openssl Allow encrypted connections using SSL + --with-nt4 Enable support for Windows NT 4 (only applies for + Windows) + --with-masterpw Enable support for a hard-coded master password + --with-updateurl Enable support for a hard-coded update URL + --with-notifyserv Enable support for a hard-coded notification server + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have + headers in a nonstandard directory + CPP C preprocessor + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +_ACEOF +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + ac_popdir=`pwd` + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d $ac_dir || continue + ac_builddir=. + +if test "$ac_dir" != .; then + ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + # A "../" for each directory in $ac_dir_suffix. + ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` +else + ac_dir_suffix= ac_top_builddir= +fi + +case $srcdir in + .) # No --srcdir option. We are building in place. + ac_srcdir=. + if test -z "$ac_top_builddir"; then + ac_top_srcdir=. + else + ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` + fi ;; + [\\/]* | ?:[\\/]* ) # Absolute path. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir ;; + *) # Relative path. + ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_builddir$srcdir ;; +esac + +# Do not use `cd foo && pwd` to compute absolute paths, because +# the directories may not exist. +case `pwd` in +.) ac_abs_builddir="$ac_dir";; +*) + case "$ac_dir" in + .) ac_abs_builddir=`pwd`;; + [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";; + *) ac_abs_builddir=`pwd`/"$ac_dir";; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_top_builddir=${ac_top_builddir}.;; +*) + case ${ac_top_builddir}. in + .) ac_abs_top_builddir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;; + *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_srcdir=$ac_srcdir;; +*) + case $ac_srcdir in + .) ac_abs_srcdir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;; + *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_top_srcdir=$ac_top_srcdir;; +*) + case $ac_top_srcdir in + .) ac_abs_top_srcdir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;; + *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;; + esac;; +esac + + cd $ac_dir + # Check for guested configure; otherwise get Cygnus style configure. + if test -f $ac_srcdir/configure.gnu; then + echo + $SHELL $ac_srcdir/configure.gnu --help=recursive + elif test -f $ac_srcdir/configure; then + echo + $SHELL $ac_srcdir/configure --help=recursive + elif test -f $ac_srcdir/configure.ac || + test -f $ac_srcdir/configure.in; then + echo + $ac_configure --help + else + echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi + cd $ac_popdir + done +fi + +test -n "$ac_init_help" && exit 0 +if $ac_init_version; then + cat <<\_ACEOF +backuppcd configure 0.1.3 +generated by GNU Autoconf 2.59 + +Copyright (C) 2003 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit 0 +fi +exec 5>config.log +cat >&5 <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by backuppcd $as_me 0.1.3, which was +generated by GNU Autoconf 2.59. Invocation command line was + + $ $0 $@ + +_ACEOF +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +hostinfo = `(hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + echo "PATH: $as_dir" +done + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_sep= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) + ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; + 2) + ac_configure_args1="$ac_configure_args1 '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" + # Get rid of the leading space. + ac_sep=" " + ;; + esac + done +done +$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } +$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Be sure not to use single quotes in there, as some shells, +# such as our DU 5.0 friend, will then `close' the trap. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + cat <<\_ASBOX +## ---------------- ## +## Cache variables. ## +## ---------------- ## +_ASBOX + echo + # The following way of writing the cache mishandles newlines in values, +{ + (set) 2>&1 | + case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in + *ac_space=\ *) + sed -n \ + "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" + ;; + *) + sed -n \ + "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" + ;; + esac; +} + echo + + cat <<\_ASBOX +## ----------------- ## +## Output variables. ## +## ----------------- ## +_ASBOX + echo + for ac_var in $ac_subst_vars + do + eval ac_val=$`echo $ac_var` + echo "$ac_var='"'"'$ac_val'"'"'" + done | sort + echo + + if test -n "$ac_subst_files"; then + cat <<\_ASBOX +## ------------- ## +## Output files. ## +## ------------- ## +_ASBOX + echo + for ac_var in $ac_subst_files + do + eval ac_val=$`echo $ac_var` + echo "$ac_var='"'"'$ac_val'"'"'" + done | sort + echo + fi + + if test -s confdefs.h; then + cat <<\_ASBOX +## ----------- ## +## confdefs.h. ## +## ----------- ## +_ASBOX + echo + sed "/^$/d" confdefs.h | sort + echo + fi + test "$ac_signal" != 0 && + echo "$as_me: caught signal $ac_signal" + echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core && + rm -rf conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status + ' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -rf conftest* confdefs.h +# AIX cpp loses on an empty file, so make sure it contains at least a newline. +echo >confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer explicitly selected file to automatically selected ones. +if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi +fi +for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then + { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 +echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special + # files actually), so we avoid doing that. + if test -f "$cache_file"; then + { echo "$as_me:$LINENO: loading cache $cache_file" >&5 +echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . $cache_file;; + *) . ./$cache_file;; + esac + fi +else + { echo "$as_me:$LINENO: creating cache $cache_file" >&5 +echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in `(set) 2>&1 | + sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val="\$ac_cv_env_${ac_var}_value" + eval ac_new_val="\$ac_env_${ac_var}_value" + case $ac_old_set,$ac_new_set in + set,) + { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 +echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 +echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 +echo "$as_me: former value: $ac_old_val" >&2;} + { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 +echo "$as_me: current value: $ac_new_val" >&2;} + ac_cache_corrupted=: + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) + ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 +echo "$as_me: error: changes in the environment can compromise the build" >&2;} + { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 +echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} + { (exit 1); exit 1; }; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + + + + + + + + + + + + + + + + + + + + + + + + + + + ac_config_headers="$ac_config_headers config.h" + + +ac_aux_dir= +for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do + if test -f $ac_dir/install-sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f $ac_dir/install.sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f $ac_dir/shtool; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5 +echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;} + { (exit 1); exit 1; }; } +fi +ac_config_guess="$SHELL $ac_aux_dir/config.guess" +ac_config_sub="$SHELL $ac_aux_dir/config.sub" +ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure. + +# Make sure we can run config.sub. +$ac_config_sub sun4 >/dev/null 2>&1 || + { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5 +echo "$as_me: error: cannot run $ac_config_sub" >&2;} + { (exit 1); exit 1; }; } + +echo "$as_me:$LINENO: checking build system type" >&5 +echo $ECHO_N "checking build system type... $ECHO_C" >&6 +if test "${ac_cv_build+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_build_alias=$build_alias +test -z "$ac_cv_build_alias" && + ac_cv_build_alias=`$ac_config_guess` +test -z "$ac_cv_build_alias" && + { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5 +echo "$as_me: error: cannot guess build type; you must specify one" >&2;} + { (exit 1); exit 1; }; } +ac_cv_build=`$ac_config_sub $ac_cv_build_alias` || + { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5 +echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;} + { (exit 1); exit 1; }; } + +fi +echo "$as_me:$LINENO: result: $ac_cv_build" >&5 +echo "${ECHO_T}$ac_cv_build" >&6 +build=$ac_cv_build +build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` + + + + echo "$as_me:$LINENO: checking host system type" >&5 +echo $ECHO_N "checking host system type... $ECHO_C" >&6 +if test "${ac_cv_host+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_host_alias=$host_alias +test -z "$ac_cv_host_alias" && + ac_cv_host_alias=$ac_cv_build_alias +ac_cv_host=`$ac_config_sub $ac_cv_host_alias` || + { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5 +echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;} + { (exit 1); exit 1; }; } + +fi +echo "$as_me:$LINENO: result: $ac_cv_host" >&5 +echo "${ECHO_T}$ac_cv_host" >&6 +host=$ac_cv_host +host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` + + + + + + + echo "$as_me:$LINENO: checking host operating system" >&5 +echo $ECHO_N "checking host operating system... $ECHO_C" >&6 + echo "$as_me:$LINENO: result: $host_os" >&5 +echo "${ECHO_T}$host_os" >&6 + + AREXT=".a" + + case $host_os in + mingw32msvc*) + CFLAGS="$CFLAGS -mno-cygwin -mms-bitfields" + CPPFLAGS="$CPPFLAGS -mno-cygwin -mms-bitfields" + ;; + cygwin*) + CFLAGS="$CFLAGS -mms-bitfields" + CPPFLAGS="$CPPFLAGS -mms-bitfields" + ;; + + esac + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + CC=$ac_ct_CC +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + CC=$ac_ct_CC +else + CC="$ac_cv_prog_CC" +fi + +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + echo "$as_me:$LINENO: result: $CC" >&5 +echo "${ECHO_T}$CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 +echo "${ECHO_T}$ac_ct_CC" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + test -n "$ac_ct_CC" && break +done + + CC=$ac_ct_CC +fi + +fi + + +test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH +See \`config.log' for more details." >&5 +echo "$as_me: error: no acceptable C compiler found in \$PATH +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } + +# Provide some information about the compiler. +echo "$as_me:$LINENO:" \ + "checking for C compiler version" >&5 +ac_compiler=`set X $ac_compile; echo $2` +{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5 + (eval $ac_compiler --version &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } +{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v &5\"") >&5 + (eval $ac_compiler -v &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } +{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V &5\"") >&5 + (eval $ac_compiler -V &5) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +echo "$as_me:$LINENO: checking for C compiler default output file name" >&5 +echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6 +ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5 + (eval $ac_link_default) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + # Find the output, starting from the most likely. This scheme is +# not robust to junk in `.', hence go to wildcards (a.*) only as a last +# resort. + +# Be careful to initialize this variable, since it used to be cached. +# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile. +ac_cv_exeext= +# b.out is created by i960 compilers. +for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) + ;; + conftest.$ac_ext ) + # This is the source file. + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + # FIXME: I believe we export ac_cv_exeext for Libtool, + # but it would be cool to find out if it's true. Does anybody + # maintain Libtool? --akim. + export ac_cv_exeext + break;; + * ) + break;; + esac +done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { echo "$as_me:$LINENO: error: C compiler cannot create executables +See \`config.log' for more details." >&5 +echo "$as_me: error: C compiler cannot create executables +See \`config.log' for more details." >&2;} + { (exit 77); exit 77; }; } +fi + +ac_exeext=$ac_cv_exeext +echo "$as_me:$LINENO: result: $ac_file" >&5 +echo "${ECHO_T}$ac_file" >&6 + +# Check the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +echo "$as_me:$LINENO: checking whether the C compiler works" >&5 +echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6 +# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 +# If not cross compiling, check that we can run a simple program. +if test "$cross_compiling" != yes; then + if { ac_try='./$ac_file' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { echo "$as_me:$LINENO: error: cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } + fi + fi +fi +echo "$as_me:$LINENO: result: yes" >&5 +echo "${ECHO_T}yes" >&6 + +rm -f a.out a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +# Check the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +echo "$as_me:$LINENO: checking whether we are cross compiling" >&5 +echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6 +echo "$as_me:$LINENO: result: $cross_compiling" >&5 +echo "${ECHO_T}$cross_compiling" >&6 + +echo "$as_me:$LINENO: checking for suffix of executables" >&5 +echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6 +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + export ac_cv_exeext + break;; + * ) break;; + esac +done +else + { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +rm -f conftest$ac_cv_exeext +echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5 +echo "${ECHO_T}$ac_cv_exeext" >&6 + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +echo "$as_me:$LINENO: checking for suffix of object files" >&5 +echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6 +if test "${ac_cv_objext+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then + for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute suffix of object files: cannot compile +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_objext" >&5 +echo "${ECHO_T}$ac_cv_objext" >&6 +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5 +echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6 +if test "${ac_cv_c_compiler_gnu+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_compiler_gnu=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_compiler_gnu=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 +echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6 +GCC=`test $ac_compiler_gnu = yes && echo yes` +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +CFLAGS="-g" +echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 +echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6 +if test "${ac_cv_prog_cc_g+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_prog_cc_g=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_prog_cc_g=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 +echo "${ECHO_T}$ac_cv_prog_cc_g" >&6 +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5 +echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6 +if test "${ac_cv_prog_cc_stdc+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_prog_cc_stdc=no +ac_save_CC=$CC +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include +#include +#include +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std1 is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std1. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +# Don't try gcc -ansi; that turns off useful extensions and +# breaks some systems' header files. +# AIX -qlanglvl=ansi +# Ultrix and OSF/1 -std1 +# HP-UX 10.20 and later -Ae +# HP-UX older versions -Aa -D_HPUX_SOURCE +# SVR4 -Xc -D__EXTENSIONS__ +for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_prog_cc_stdc=$ac_arg +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext +done +rm -f conftest.$ac_ext conftest.$ac_objext +CC=$ac_save_CC + +fi + +case "x$ac_cv_prog_cc_stdc" in + x|xno) + echo "$as_me:$LINENO: result: none needed" >&5 +echo "${ECHO_T}none needed" >&6 ;; + *) + echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5 +echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6 + CC="$CC $ac_cv_prog_cc_stdc" ;; +esac + +# Some people use a C++ compiler to compile C. Since we use `exit', +# in C++ we need to declare it. In case someone uses the same compiler +# for both compiling C and C++ we need to have the C++ compiler decide +# the declaration of exit, since it's the most demanding environment. +cat >conftest.$ac_ext <<_ACEOF +#ifndef __cplusplus + choke me +#endif +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + for ac_declaration in \ + '' \ + 'extern "C" void std::exit (int) throw (); using std::exit;' \ + 'extern "C" void std::exit (int); using std::exit;' \ + 'extern "C" void exit (int) throw ();' \ + 'extern "C" void exit (int);' \ + 'void exit (int);' +do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_declaration +#include +int +main () +{ +exit (42); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +continue +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_declaration +int +main () +{ +exit (42); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +rm -f conftest* +if test -n "$ac_declaration"; then + echo '#ifdef __cplusplus' >>confdefs.h + echo $ac_declaration >>confdefs.h + echo '#endif' >>confdefs.h +fi + +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6 +set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'` +if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.make <<\_ACEOF +all: + @echo 'ac_maketemp="$(MAKE)"' +_ACEOF +# GNU make sometimes prints "make[1]: Entering...", which would confuse us. +eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=` +if test -n "$ac_maketemp"; then + eval ac_cv_prog_make_${ac_make}_set=yes +else + eval ac_cv_prog_make_${ac_make}_set=no +fi +rm -f conftest.make +fi +if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then + echo "$as_me:$LINENO: result: yes" >&5 +echo "${ECHO_T}yes" >&6 + SET_MAKE= +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 + SET_MAKE="MAKE=${MAKE-make}" +fi + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 +echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6 +if test -z "$INSTALL"; then +if test "${ac_cv_path_install+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in + ./ | .// | /cC/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + done + done + ;; +esac +done + + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. We don't cache a + # path for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the path is relative. + INSTALL=$ac_install_sh + fi +fi +echo "$as_me:$LINENO: result: $INSTALL" >&5 +echo "${ECHO_T}$INSTALL" >&6 + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_RANLIB+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + echo "$as_me:$LINENO: result: $RANLIB" >&5 +echo "${ECHO_T}$RANLIB" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + + test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":" +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 +echo "${ECHO_T}$ac_ct_RANLIB" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + RANLIB=$ac_ct_RANLIB +else + RANLIB="$ac_cv_prog_RANLIB" +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 +echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6 +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if test "${ac_cv_prog_CPP+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.$ac_ext + + # OK, works on sane cases. Now check whether non-existent headers + # can be detected and how. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + # Broken: success on invalid input. +continue +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.err conftest.$ac_ext +if $ac_preproc_ok; then + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +echo "$as_me:$LINENO: result: $CPP" >&5 +echo "${ECHO_T}$CPP" >&6 +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + : +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.$ac_ext + + # OK, works on sane cases. Now check whether non-existent headers + # can be detected and how. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + # Broken: success on invalid input. +continue +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.err conftest.$ac_ext +if $ac_preproc_ok; then + : +else + { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details." >&5 +echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +echo "$as_me:$LINENO: checking for egrep" >&5 +echo $ECHO_N "checking for egrep... $ECHO_C" >&6 +if test "${ac_cv_prog_egrep+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if echo a | (grep -E '(a|b)') >/dev/null 2>&1 + then ac_cv_prog_egrep='grep -E' + else ac_cv_prog_egrep='egrep' + fi +fi +echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5 +echo "${ECHO_T}$ac_cv_prog_egrep" >&6 + EGREP=$ac_cv_prog_egrep + + + +echo "$as_me:$LINENO: checking for AIX" >&5 +echo $ECHO_N "checking for AIX... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifdef _AIX + yes +#endif + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "yes" >/dev/null 2>&1; then + echo "$as_me:$LINENO: result: yes" >&5 +echo "${ECHO_T}yes" >&6 +cat >>confdefs.h <<\_ACEOF +#define _ALL_SOURCE 1 +_ACEOF + +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi +rm -f conftest* + + + +cat >>confdefs.h <<\_ACEOF +#define _GNU_SOURCE 1 +_ACEOF + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. +set dummy ${ac_tool_prefix}ar; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_AR+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="${ac_tool_prefix}ar" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + echo "$as_me:$LINENO: result: $AR" >&5 +echo "${ECHO_T}$AR" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + +fi +if test -z "$ac_cv_prog_AR"; then + ac_ct_AR=$AR + # Extract the first word of "ar", so it can be a program name with args. +set dummy ar; ac_word=$2 +echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 +if test "${ac_cv_prog_ac_ct_AR+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="ar" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done + + test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="true" +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + echo "$as_me:$LINENO: result: $ac_ct_AR" >&5 +echo "${ECHO_T}$ac_ct_AR" >&6 +else + echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6 +fi + + AR=$ac_ct_AR +else + AR="$ac_cv_prog_AR" +fi + + +echo "$as_me:$LINENO: checking for ANSI C header files" >&5 +echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6 +if test "${ac_cv_header_stdc+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_header_stdc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_header_stdc=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then + : +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then + : +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then + : +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + exit(2); + exit (0); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + : +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +ac_cv_header_stdc=no +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 +echo "${ECHO_T}$ac_cv_header_stdc" >&6 +if test $ac_cv_header_stdc = yes; then + +cat >>confdefs.h <<\_ACEOF +#define STDC_HEADERS 1 +_ACEOF + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. + + + + + + + + + +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default + +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + eval "$as_ac_Header=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +eval "$as_ac_Header=no" +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +for ac_header in stdlib.h string.h unistd.h time.h sys/time.h sys/types.h signal.h syslog.h sys/select.h netinet/in.h arpa/inet.h sys/socket.h ssl.h openssl/ssl.h ssl/ssl.h fcntl.h dirent.h ctype.h assert.h endian.h stdarg.h utime.h fnmatch.h sys/vfs.h sys/statfs.h sys/param.h sys/mount.h sys/resource.h limits.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking $ac_header usability" >&5 +echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking $ac_header presence" >&5 +echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <$ac_header> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + eval "$as_ac_Header=\$ac_header_preproc" +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 + +fi +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + +echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5 +echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6 +if test "${ac_cv_header_time+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include +#include + +int +main () +{ +if ((struct tm *) 0) +return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_header_time=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_header_time=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5 +echo "${ECHO_T}$ac_cv_header_time" >&6 +if test $ac_cv_header_time = yes; then + +cat >>confdefs.h <<\_ACEOF +#define TIME_WITH_SYS_TIME 1 +_ACEOF + +fi + + + + + + + + + + + + + + + + + + +for ac_func in sysinfo openlog syslog setsid fork fcntl stat lstat lchown symlink readlink signal getenv utime statfs getmntinfo setpriority +do +as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +echo "$as_me:$LINENO: checking for $ac_func" >&5 +echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6 +if eval "test \"\${$as_ac_var+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +/* Define $ac_func to an innocuous variant, in case declares $ac_func. + For example, HP-UX 11i declares gettimeofday. */ +#define $ac_func innocuous_$ac_func + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $ac_func (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $ac_func + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +{ +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +char (*f) () = $ac_func; +#endif +#ifdef __cplusplus +} +#endif + +int +main () +{ +return f != $ac_func; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + eval "$as_ac_var=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +eval "$as_ac_var=no" +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6 +if test `eval echo '${'$as_ac_var'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + +fi +done + + + + + + + + +for ac_func in htonll ntohll chown link fnmatch strsep gethostname +do +as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +echo "$as_me:$LINENO: checking for $ac_func" >&5 +echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6 +if eval "test \"\${$as_ac_var+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +/* Define $ac_func to an innocuous variant, in case declares $ac_func. + For example, HP-UX 11i declares gettimeofday. */ +#define $ac_func innocuous_$ac_func + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $ac_func (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $ac_func + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +{ +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +char (*f) () = $ac_func; +#endif +#ifdef __cplusplus +} +#endif + +int +main () +{ +return f != $ac_func; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + eval "$as_ac_var=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +eval "$as_ac_var=no" +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6 +if test `eval echo '${'$as_ac_var'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + +else + case $LIBOBJS in + "$ac_func.$ac_objext" | \ + *" $ac_func.$ac_objext" | \ + "$ac_func.$ac_objext "* | \ + *" $ac_func.$ac_objext "* ) ;; + *) LIBOBJS="$LIBOBJS $ac_func.$ac_objext" ;; +esac + +fi +done + + + + + + + + + + + + + + + + + + +for ac_header in arpa/inet.h errno.h fcntl.h netdb.h netinet/in.h stdarg.h stdio.h stdlib.h string.h sys/socket.h sys/stat.h sys/types.h unistd.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking $ac_header usability" >&5 +echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking $ac_header presence" >&5 +echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <$ac_header> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + eval "$as_ac_Header=\$ac_header_preproc" +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 + +fi +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + + echo "$as_me:$LINENO: checking for socklen_t" >&5 +echo $ECHO_N "checking for socklen_t... $ECHO_C" >&6 +if test "${ac_cv_type_socklen_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_SYS_SOCKET_H +#include +#endif + + +int +main () +{ +if ((socklen_t *) 0) + return 0; +if (sizeof (socklen_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_socklen_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_socklen_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_socklen_t" >&5 +echo "${ECHO_T}$ac_cv_type_socklen_t" >&6 +if test $ac_cv_type_socklen_t = yes; then + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_SOCKLEN_T 1 +_ACEOF + + +else + + +cat >>confdefs.h <<\_ACEOF +#define NEED_SOCKLEN_T 1 +_ACEOF + + +fi + + + echo "$as_me:$LINENO: checking for library containing inet_aton" >&5 +echo $ECHO_N "checking for library containing inet_aton... $ECHO_C" >&6 +if test "${ac_cv_search_inet_aton+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_func_search_save_LIBS=$LIBS +ac_cv_search_inet_aton=no +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_aton (); +int +main () +{ +inet_aton (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_aton="none required" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test "$ac_cv_search_inet_aton" = no; then + for ac_lib in xnet ws2_32 wsock32; do + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_aton (); +int +main () +{ +inet_aton (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_aton="-l$ac_lib" +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + done +fi +LIBS=$ac_func_search_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_search_inet_aton" >&5 +echo "${ECHO_T}$ac_cv_search_inet_aton" >&6 +if test "$ac_cv_search_inet_aton" != no; then + test "$ac_cv_search_inet_aton" = "none required" || LIBS="$ac_cv_search_inet_aton $LIBS" + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_INET_ATON 1 +_ACEOF + + +else + + echo "$as_me:$LINENO: checking for library containing inet_addr" >&5 +echo $ECHO_N "checking for library containing inet_addr... $ECHO_C" >&6 +if test "${ac_cv_search_inet_addr+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_func_search_save_LIBS=$LIBS +ac_cv_search_inet_addr=no +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_addr (); +int +main () +{ +inet_addr (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_addr="none required" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test "$ac_cv_search_inet_addr" = no; then + for ac_lib in nsl ws2_32 wsock32; do + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_addr (); +int +main () +{ +inet_addr (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_addr="-l$ac_lib" +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + done +fi +LIBS=$ac_func_search_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_search_inet_addr" >&5 +echo "${ECHO_T}$ac_cv_search_inet_addr" >&6 +if test "$ac_cv_search_inet_addr" != no; then + test "$ac_cv_search_inet_addr" = "none required" || LIBS="$ac_cv_search_inet_addr $LIBS" + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_INET_ADDR 1 +_ACEOF + + +else + + { echo "$as_me:$LINENO: WARNING: Couldn't find inet_addr or inet_aton" >&5 +echo "$as_me: WARNING: Couldn't find inet_addr or inet_aton" >&2;} + +fi + + +fi + + echo "$as_me:$LINENO: checking for library containing connect" >&5 +echo $ECHO_N "checking for library containing connect... $ECHO_C" >&6 +if test "${ac_cv_search_connect+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_func_search_save_LIBS=$LIBS +ac_cv_search_connect=no +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char connect (); +int +main () +{ +connect (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_connect="none required" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test "$ac_cv_search_connect" = no; then + for ac_lib in socket nsl ws2_32 wsock32; do + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char connect (); +int +main () +{ +connect (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_connect="-l$ac_lib" +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + done +fi +LIBS=$ac_func_search_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_search_connect" >&5 +echo "${ECHO_T}$ac_cv_search_connect" >&6 +if test "$ac_cv_search_connect" != no; then + test "$ac_cv_search_connect" = "none required" || LIBS="$ac_cv_search_connect $LIBS" + +else + { echo "$as_me:$LINENO: WARNING: Couldn't find connect" >&5 +echo "$as_me: WARNING: Couldn't find connect" >&2;} +fi + + echo "$as_me:$LINENO: checking for library containing inet_ntoa" >&5 +echo $ECHO_N "checking for library containing inet_ntoa... $ECHO_C" >&6 +if test "${ac_cv_search_inet_ntoa+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_func_search_save_LIBS=$LIBS +ac_cv_search_inet_ntoa=no +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_ntoa (); +int +main () +{ +inet_ntoa (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_ntoa="none required" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +if test "$ac_cv_search_inet_ntoa" = no; then + for ac_lib in socket nsl ws2_32 wsock32; do + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char inet_ntoa (); +int +main () +{ +inet_ntoa (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_search_inet_ntoa="-l$ac_lib" +break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + done +fi +LIBS=$ac_func_search_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_search_inet_ntoa" >&5 +echo "${ECHO_T}$ac_cv_search_inet_ntoa" >&6 +if test "$ac_cv_search_inet_ntoa" != no; then + test "$ac_cv_search_inet_ntoa" = "none required" || LIBS="$ac_cv_search_inet_ntoa $LIBS" + +else + { echo "$as_me:$LINENO: WARNING: Couldn't find inet_ntoa" >&5 +echo "$as_me: WARNING: Couldn't find inet_ntoa" >&2;} +fi + + + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "8"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for uint64_t" >&5 +echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint64_t *) 0) + return 0; +if (sizeof (uint64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint64_t" >&6 +if test $ac_cv_type_uint64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint64_t unsigned int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for uint64_t" >&5 +echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint64_t *) 0) + return 0; +if (sizeof (uint64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint64_t" >&6 +if test $ac_cv_type_uint64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint64_t unsigned long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for uint64_t" >&5 +echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint64_t *) 0) + return 0; +if (sizeof (uint64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint64_t" >&6 +if test $ac_cv_type_uint64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint64_t unsigned long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for uint64_t" >&5 +echo $ECHO_N "checking for uint64_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint64_t *) 0) + return 0; +if (sizeof (uint64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint64_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint64_t" >&6 +if test $ac_cv_type_uint64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint64_t unsigned short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "8"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for int64_t" >&5 +echo $ECHO_N "checking for int64_t... $ECHO_C" >&6 +if test "${ac_cv_type_int64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int64_t *) 0) + return 0; +if (sizeof (int64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int64_t" >&5 +echo "${ECHO_T}$ac_cv_type_int64_t" >&6 +if test $ac_cv_type_int64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int64_t signed int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for int64_t" >&5 +echo $ECHO_N "checking for int64_t... $ECHO_C" >&6 +if test "${ac_cv_type_int64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int64_t *) 0) + return 0; +if (sizeof (int64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int64_t" >&5 +echo "${ECHO_T}$ac_cv_type_int64_t" >&6 +if test $ac_cv_type_int64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int64_t signed long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for int64_t" >&5 +echo $ECHO_N "checking for int64_t... $ECHO_C" >&6 +if test "${ac_cv_type_int64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int64_t *) 0) + return 0; +if (sizeof (int64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int64_t" >&5 +echo "${ECHO_T}$ac_cv_type_int64_t" >&6 +if test $ac_cv_type_int64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int64_t signed long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for int64_t" >&5 +echo $ECHO_N "checking for int64_t... $ECHO_C" >&6 +if test "${ac_cv_type_int64_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int64_t *) 0) + return 0; +if (sizeof (int64_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int64_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int64_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int64_t" >&5 +echo "${ECHO_T}$ac_cv_type_int64_t" >&6 +if test $ac_cv_type_int64_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int64_t signed short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "4"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for uint32_t" >&5 +echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint32_t *) 0) + return 0; +if (sizeof (uint32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint32_t" >&6 +if test $ac_cv_type_uint32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint32_t unsigned int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for uint32_t" >&5 +echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint32_t *) 0) + return 0; +if (sizeof (uint32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint32_t" >&6 +if test $ac_cv_type_uint32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint32_t unsigned long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for uint32_t" >&5 +echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint32_t *) 0) + return 0; +if (sizeof (uint32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint32_t" >&6 +if test $ac_cv_type_uint32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint32_t unsigned long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for uint32_t" >&5 +echo $ECHO_N "checking for uint32_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint32_t *) 0) + return 0; +if (sizeof (uint32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint32_t" >&6 +if test $ac_cv_type_uint32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint32_t unsigned short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "4"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for int32_t" >&5 +echo $ECHO_N "checking for int32_t... $ECHO_C" >&6 +if test "${ac_cv_type_int32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int32_t *) 0) + return 0; +if (sizeof (int32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int32_t" >&5 +echo "${ECHO_T}$ac_cv_type_int32_t" >&6 +if test $ac_cv_type_int32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int32_t signed int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for int32_t" >&5 +echo $ECHO_N "checking for int32_t... $ECHO_C" >&6 +if test "${ac_cv_type_int32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int32_t *) 0) + return 0; +if (sizeof (int32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int32_t" >&5 +echo "${ECHO_T}$ac_cv_type_int32_t" >&6 +if test $ac_cv_type_int32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int32_t signed long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for int32_t" >&5 +echo $ECHO_N "checking for int32_t... $ECHO_C" >&6 +if test "${ac_cv_type_int32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int32_t *) 0) + return 0; +if (sizeof (int32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int32_t" >&5 +echo "${ECHO_T}$ac_cv_type_int32_t" >&6 +if test $ac_cv_type_int32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int32_t signed long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for int32_t" >&5 +echo $ECHO_N "checking for int32_t... $ECHO_C" >&6 +if test "${ac_cv_type_int32_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int32_t *) 0) + return 0; +if (sizeof (int32_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int32_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int32_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int32_t" >&5 +echo "${ECHO_T}$ac_cv_type_int32_t" >&6 +if test $ac_cv_type_int32_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int32_t signed short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "2"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for uint16_t" >&5 +echo $ECHO_N "checking for uint16_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint16_t *) 0) + return 0; +if (sizeof (uint16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint16_t" >&6 +if test $ac_cv_type_uint16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint16_t unsigned int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for uint16_t" >&5 +echo $ECHO_N "checking for uint16_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint16_t *) 0) + return 0; +if (sizeof (uint16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint16_t" >&6 +if test $ac_cv_type_uint16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint16_t unsigned long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for uint16_t" >&5 +echo $ECHO_N "checking for uint16_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint16_t *) 0) + return 0; +if (sizeof (uint16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint16_t" >&6 +if test $ac_cv_type_uint16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint16_t unsigned long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for uint16_t" >&5 +echo $ECHO_N "checking for uint16_t... $ECHO_C" >&6 +if test "${ac_cv_type_uint16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((uint16_t *) 0) + return 0; +if (sizeof (uint16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_uint16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_uint16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5 +echo "${ECHO_T}$ac_cv_type_uint16_t" >&6 +if test $ac_cv_type_uint16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define uint16_t unsigned short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + + + if test -z "$ac_cv_sizeof_long"; then + echo "$as_me:$LINENO: checking for inline" >&5 +echo $ECHO_N "checking for inline... $ECHO_C" >&6 +if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_c_inline=no +for ac_kw in inline __inline__ __inline; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#ifndef __cplusplus +typedef int foo_t; +static $ac_kw foo_t static_foo () {return 0; } +$ac_kw foo_t foo () {return 0; } +#endif + +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_inline=$ac_kw; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done + +fi +echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +echo "${ECHO_T}$ac_cv_c_inline" >&6 + + +case $ac_cv_c_inline in + inline | yes) ;; + *) + case $ac_cv_c_inline in + no) ac_val=;; + *) ac_val=$ac_cv_c_inline;; + esac + cat >>confdefs.h <<_ACEOF +#ifndef __cplusplus +#define inline $ac_val +#endif +_ACEOF + ;; +esac + + echo "$as_me:$LINENO: checking for long long" >&5 +echo $ECHO_N "checking for long long... $ECHO_C" >&6 +if test "${ac_cv_type_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long long *) 0) + return 0; +if (sizeof (long long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 +echo "${ECHO_T}$ac_cv_type_long_long" >&6 + +echo "$as_me:$LINENO: checking size of long long" >&5 +echo $ECHO_N "checking size of long long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long long)); } +unsigned long ulongval () { return (long) (sizeof (long long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG_LONG $ac_cv_sizeof_long_long +_ACEOF + + + echo "$as_me:$LINENO: checking for long" >&5 +echo $ECHO_N "checking for long... $ECHO_C" >&6 +if test "${ac_cv_type_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((long *) 0) + return 0; +if (sizeof (long)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_long=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_long=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5 +echo "${ECHO_T}$ac_cv_type_long" >&6 + +echo "$as_me:$LINENO: checking size of long" >&5 +echo $ECHO_N "checking size of long... $ECHO_C" >&6 +if test "${ac_cv_sizeof_long+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_long" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_long=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (long)); } +unsigned long ulongval () { return (long) (sizeof (long)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (long))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (long)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_long=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (long), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_long=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5 +echo "${ECHO_T}$ac_cv_sizeof_long" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_LONG $ac_cv_sizeof_long +_ACEOF + + + echo "$as_me:$LINENO: checking for int" >&5 +echo $ECHO_N "checking for int... $ECHO_C" >&6 +if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int *) 0) + return 0; +if (sizeof (int)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +echo "${ECHO_T}$ac_cv_type_int" >&6 + +echo "$as_me:$LINENO: checking size of int" >&5 +echo $ECHO_N "checking size of int... $ECHO_C" >&6 +if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_int" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (int))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_int=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (int)); } +unsigned long ulongval () { return (long) (sizeof (int)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (int))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (int)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_int=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (int), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_int=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_int" >&5 +echo "${ECHO_T}$ac_cv_sizeof_int" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_INT $ac_cv_sizeof_int +_ACEOF + + + echo "$as_me:$LINENO: checking for short" >&5 +echo $ECHO_N "checking for short... $ECHO_C" >&6 +if test "${ac_cv_type_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((short *) 0) + return 0; +if (sizeof (short)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_short=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_short=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_short" >&5 +echo "${ECHO_T}$ac_cv_type_short" >&6 + +echo "$as_me:$LINENO: checking size of short" >&5 +echo $ECHO_N "checking size of short... $ECHO_C" >&6 +if test "${ac_cv_sizeof_short+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_short" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (short))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_short=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (short)); } +unsigned long ulongval () { return (long) (sizeof (short)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (short))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (short)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_short=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (short), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_short=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_short" >&5 +echo "${ECHO_T}$ac_cv_sizeof_short" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SHORT $ac_cv_sizeof_short +_ACEOF + + + fi + FOUND=0 + for dc_cv_loop in \$ac_cv_sizeof_long_long \$ac_cv_sizeof_int \$ac_cv_sizeof_long \$ac_cv_sizeof_short; do + dc_cv_size=`eval echo $dc_cv_loop` + dc_cv_name=`echo $dc_cv_loop | sed s/\\\$ac_cv_sizeof_//` + if test "$dc_cv_size" = "2"; then + if test "$dc_cv_name" = "int"; then + echo "$as_me:$LINENO: checking for int16_t" >&5 +echo $ECHO_N "checking for int16_t... $ECHO_C" >&6 +if test "${ac_cv_type_int16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int16_t *) 0) + return 0; +if (sizeof (int16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int16_t" >&5 +echo "${ECHO_T}$ac_cv_type_int16_t" >&6 +if test $ac_cv_type_int16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int16_t signed int +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long"; then + echo "$as_me:$LINENO: checking for int16_t" >&5 +echo $ECHO_N "checking for int16_t... $ECHO_C" >&6 +if test "${ac_cv_type_int16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int16_t *) 0) + return 0; +if (sizeof (int16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int16_t" >&5 +echo "${ECHO_T}$ac_cv_type_int16_t" >&6 +if test $ac_cv_type_int16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int16_t signed long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "long_long"; then + echo "$as_me:$LINENO: checking for int16_t" >&5 +echo $ECHO_N "checking for int16_t... $ECHO_C" >&6 +if test "${ac_cv_type_int16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int16_t *) 0) + return 0; +if (sizeof (int16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int16_t" >&5 +echo "${ECHO_T}$ac_cv_type_int16_t" >&6 +if test $ac_cv_type_int16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int16_t signed long long +_ACEOF + +fi + + fi + if test "$dc_cv_name" = "short"; then + echo "$as_me:$LINENO: checking for int16_t" >&5 +echo $ECHO_N "checking for int16_t... $ECHO_C" >&6 +if test "${ac_cv_type_int16_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((int16_t *) 0) + return 0; +if (sizeof (int16_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_int16_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_int16_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_int16_t" >&5 +echo "${ECHO_T}$ac_cv_type_int16_t" >&6 +if test $ac_cv_type_int16_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define int16_t signed short +_ACEOF + +fi + + fi + FOUND=1 + break + fi + done + +echo "$as_me:$LINENO: checking for uid_t in sys/types.h" >&5 +echo $ECHO_N "checking for uid_t in sys/types.h... $ECHO_C" >&6 +if test "${ac_cv_type_uid_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "uid_t" >/dev/null 2>&1; then + ac_cv_type_uid_t=yes +else + ac_cv_type_uid_t=no +fi +rm -f conftest* + +fi +echo "$as_me:$LINENO: result: $ac_cv_type_uid_t" >&5 +echo "${ECHO_T}$ac_cv_type_uid_t" >&6 +if test $ac_cv_type_uid_t = no; then + +cat >>confdefs.h <<\_ACEOF +#define uid_t int +_ACEOF + + +cat >>confdefs.h <<\_ACEOF +#define gid_t int +_ACEOF + +fi + + + + + + +for ac_header in windows.h windowsx.h winsock2.h +do +as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking $ac_header usability" >&5 +echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <$ac_header> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking $ac_header presence" >&5 +echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <$ac_header> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for $ac_header" >&5 +echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6 +if eval "test \"\${$as_ac_Header+set}\" = set"; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + eval "$as_ac_Header=\$ac_header_preproc" +fi +echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5 +echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6 + +fi +if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + + echo "$as_me:$LINENO: checking for main in -lwsock32" >&5 +echo $ECHO_N "checking for main in -lwsock32... $ECHO_C" >&6 +if test "${ac_cv_lib_wsock32_main+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lwsock32 $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + + +int +main () +{ +main (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_wsock32_main=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_wsock32_main=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_wsock32_main" >&5 +echo "${ECHO_T}$ac_cv_lib_wsock32_main" >&6 +if test $ac_cv_lib_wsock32_main = yes; then + + +cat >>confdefs.h <<\_ACEOF +#define HAVE_LIBWSOCK32 1 +_ACEOF + + LIBS="${LIBS} -lwsock32" + +fi + + + +# Check whether --enable-largefile or --disable-largefile was given. +if test "${enable_largefile+set}" = set; then + enableval="$enable_largefile" + +fi; +if test "$enable_largefile" != no; then + + echo "$as_me:$LINENO: checking for special C compiler options needed for large files" >&5 +echo $ECHO_N "checking for special C compiler options needed for large files... $ECHO_C" >&6 +if test "${ac_cv_sys_largefile_CC+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_sys_largefile_CC=no + if test "$GCC" != yes; then + ac_save_CC=$CC + while :; do + # IRIX 6.2 and later do not support large files by default, + # so use the C compiler's -n32 option if that helps. + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]; +int +main () +{ + + ; + return 0; +} +_ACEOF + rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext + CC="$CC -n32" + rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sys_largefile_CC=' -n32'; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext + break + done + CC=$ac_save_CC + rm -f conftest.$ac_ext + fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_CC" >&5 +echo "${ECHO_T}$ac_cv_sys_largefile_CC" >&6 + if test "$ac_cv_sys_largefile_CC" != no; then + CC=$CC$ac_cv_sys_largefile_CC + fi + + echo "$as_me:$LINENO: checking for _FILE_OFFSET_BITS value needed for large files" >&5 +echo $ECHO_N "checking for _FILE_OFFSET_BITS value needed for large files... $ECHO_C" >&6 +if test "${ac_cv_sys_file_offset_bits+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + while :; do + ac_cv_sys_file_offset_bits=no + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]; +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#define _FILE_OFFSET_BITS 64 +#include + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]; +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sys_file_offset_bits=64; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + break +done +fi +echo "$as_me:$LINENO: result: $ac_cv_sys_file_offset_bits" >&5 +echo "${ECHO_T}$ac_cv_sys_file_offset_bits" >&6 +if test "$ac_cv_sys_file_offset_bits" != no; then + +cat >>confdefs.h <<_ACEOF +#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits +_ACEOF + +fi +rm -f conftest* + echo "$as_me:$LINENO: checking for _LARGE_FILES value needed for large files" >&5 +echo $ECHO_N "checking for _LARGE_FILES value needed for large files... $ECHO_C" >&6 +if test "${ac_cv_sys_large_files+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + while :; do + ac_cv_sys_large_files=no + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]; +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#define _LARGE_FILES 1 +#include + /* Check that off_t can represent 2**63 - 1 correctly. + We can't simply define LARGE_OFF_T to be 9223372036854775807, + since some C++ compilers masquerading as C compilers + incorrectly reject 9223372036854775807. */ +#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62)) + int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721 + && LARGE_OFF_T % 2147483647 == 1) + ? 1 : -1]; +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sys_large_files=1; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + break +done +fi +echo "$as_me:$LINENO: result: $ac_cv_sys_large_files" >&5 +echo "${ECHO_T}$ac_cv_sys_large_files" >&6 +if test "$ac_cv_sys_large_files" != no; then + +cat >>confdefs.h <<_ACEOF +#define _LARGE_FILES $ac_cv_sys_large_files +_ACEOF + +fi +rm -f conftest* +fi + +echo "$as_me:$LINENO: checking for _LARGEFILE_SOURCE value needed for large files" >&5 +echo $ECHO_N "checking for _LARGEFILE_SOURCE value needed for large files... $ECHO_C" >&6 +if test "${ac_cv_sys_largefile_source+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + while :; do + ac_cv_sys_largefile_source=no + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +int +main () +{ +return !fseeko; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#define _LARGEFILE_SOURCE 1 +#include +int +main () +{ +return !fseeko; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sys_largefile_source=1; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + break +done +fi +echo "$as_me:$LINENO: result: $ac_cv_sys_largefile_source" >&5 +echo "${ECHO_T}$ac_cv_sys_largefile_source" >&6 +if test "$ac_cv_sys_largefile_source" != no; then + +cat >>confdefs.h <<_ACEOF +#define _LARGEFILE_SOURCE $ac_cv_sys_largefile_source +_ACEOF + +fi +rm -f conftest* + +# We used to try defining _XOPEN_SOURCE=500 too, to work around a bug +# in glibc 2.1.3, but that breaks too many other things. +# If you want fseeko and ftello with glibc, upgrade to a fixed glibc. +echo "$as_me:$LINENO: checking for fseeko" >&5 +echo $ECHO_N "checking for fseeko... $ECHO_C" >&6 +if test "${ac_cv_func_fseeko+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +int +main () +{ +return fseeko && fseeko (stdin, 0, 0); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_func_fseeko=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_func_fseeko=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_func_fseeko" >&5 +echo "${ECHO_T}$ac_cv_func_fseeko" >&6 +if test $ac_cv_func_fseeko = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_FSEEKO 1 +_ACEOF + +fi + +echo "$as_me:$LINENO: checking for off_t" >&5 +echo $ECHO_N "checking for off_t... $ECHO_C" >&6 +if test "${ac_cv_type_off_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((off_t *) 0) + return 0; +if (sizeof (off_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_off_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_off_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5 +echo "${ECHO_T}$ac_cv_type_off_t" >&6 +if test $ac_cv_type_off_t = yes; then + : +else + +cat >>confdefs.h <<_ACEOF +#define off_t long +_ACEOF + +fi + + + + LIBSPECLIBDIR="" + +# Check whether --with-opennet or --without-opennet was given. +if test "${with_opennet+set}" = set; then + withval="$with_opennet" + +# Specified + LIBSPEC=$withval + +else + +# Not specified + LIBSPECFLAGS="`pkg-config --libs opennet 2>/dev/null`" + LIBSPECCFLAGS="`pkg-config --cflags opennet 2>/dev/null`" + echo "$as_me:$LINENO: checking for fopen_net in -lopennet" >&5 +echo $ECHO_N "checking for fopen_net in -lopennet... $ECHO_C" >&6 +if test "${ac_cv_lib_opennet_fopen_net+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lopennet $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char fopen_net (); +int +main () +{ +fopen_net (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_opennet_fopen_net=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_opennet_fopen_net=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_opennet_fopen_net" >&5 +echo "${ECHO_T}$ac_cv_lib_opennet_fopen_net" >&6 +if test $ac_cv_lib_opennet_fopen_net = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "opennet.h" ; then + if test "${ac_cv_header_opennet_h+set}" = set; then + echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking opennet.h usability" >&5 +echo $ECHO_N "checking opennet.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking opennet.h presence" >&5 +echo $ECHO_N "checking opennet.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: opennet.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: opennet.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: opennet.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: opennet.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: opennet.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_opennet_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 + +fi +if test $ac_cv_header_opennet_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + if test -n ""; then + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS=" $LIBSPECFLAGS" + echo "$as_me:$LINENO: checking for fopen_net in -lopennet" >&5 +echo $ECHO_N "checking for fopen_net in -lopennet... $ECHO_C" >&6 +if test "${ac_cv_lib_opennet_fopen_net+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lopennet $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char fopen_net (); +int +main () +{ +fopen_net (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_opennet_fopen_net=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_opennet_fopen_net=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_opennet_fopen_net" >&5 +echo "${ECHO_T}$ac_cv_lib_opennet_fopen_net" >&6 +if test $ac_cv_lib_opennet_fopen_net = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "opennet.h" ; then + if test "${ac_cv_header_opennet_h+set}" = set; then + echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking opennet.h usability" >&5 +echo $ECHO_N "checking opennet.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking opennet.h presence" >&5 +echo $ECHO_N "checking opennet.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: opennet.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: opennet.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: opennet.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: opennet.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: opennet.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_opennet_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 + +fi +if test $ac_cv_header_opennet_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="" + echo "$as_me:$LINENO: checking for fopen_net in -lopennet" >&5 +echo $ECHO_N "checking for fopen_net in -lopennet... $ECHO_C" >&6 +if test "${ac_cv_lib_opennet_fopen_net+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lopennet $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char fopen_net (); +int +main () +{ +fopen_net (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_opennet_fopen_net=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_opennet_fopen_net=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_opennet_fopen_net" >&5 +echo "${ECHO_T}$ac_cv_lib_opennet_fopen_net" >&6 +if test $ac_cv_lib_opennet_fopen_net = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "opennet.h" ; then + if test "${ac_cv_header_opennet_h+set}" = set; then + echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking opennet.h usability" >&5 +echo $ECHO_N "checking opennet.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking opennet.h presence" >&5 +echo $ECHO_N "checking opennet.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: opennet.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: opennet.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: opennet.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: opennet.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: opennet.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_opennet_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 + +fi +if test $ac_cv_header_opennet_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + LIBSPEC=no + + { echo "$as_me:$LINENO: WARNING: Did not find opennet" >&5 +echo "$as_me: WARNING: Did not find opennet" >&2;} + +fi + + +fi + + else + LIBSPEC=no + + { echo "$as_me:$LINENO: WARNING: Did not find opennet" >&5 +echo "$as_me: WARNING: Did not find opennet" >&2;} + fi + +fi + + +fi; + case $LIBSPEC in + no) + + { echo "$as_me:$LINENO: WARNING: Support for opennet disabled" >&5 +echo "$as_me: WARNING: Support for opennet disabled" >&2;} + ;; + *) + if test "${LIBSPEC}" = "yes"; then + true + else + LIBSPECLIBDIR="${LIBSPEC}/lib" + LIBSPECFLAGS="-L${LIBSPEC}/lib ${LIBSPECFLAGS}" + LIBSPECCFLAGS="-I${LIBSPEC}/include ${LIBSPECCFLAGS}" + fi + echo "$as_me:$LINENO: checking for fopen_net in -lopennet" >&5 +echo $ECHO_N "checking for fopen_net in -lopennet... $ECHO_C" >&6 +if test "${ac_cv_lib_opennet_fopen_net+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lopennet $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char fopen_net (); +int +main () +{ +fopen_net (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_opennet_fopen_net=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_opennet_fopen_net=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_opennet_fopen_net" >&5 +echo "${ECHO_T}$ac_cv_lib_opennet_fopen_net" >&6 +if test $ac_cv_lib_opennet_fopen_net = yes; then + + OLDCFLAGS="$CFLAGS" + OLDCPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS ${LIBSPECCFLAGS}" + CFLAGS="$CFLAGS ${LIBSPECCFLAGS}" + if test -n "opennet.h"; then + if test "${ac_cv_header_opennet_h+set}" = set; then + echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking opennet.h usability" >&5 +echo $ECHO_N "checking opennet.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking opennet.h presence" >&5 +echo $ECHO_N "checking opennet.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: opennet.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: opennet.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: opennet.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: opennet.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: opennet.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: opennet.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: opennet.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: opennet.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: opennet.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for opennet.h" >&5 +echo $ECHO_N "checking for opennet.h... $ECHO_C" >&6 +if test "${ac_cv_header_opennet_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_opennet_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_opennet_h" >&5 +echo "${ECHO_T}$ac_cv_header_opennet_h" >&6 + +fi +if test $ac_cv_header_opennet_h = yes; then + + headerok="yes" + +else + + headerok="no" + +fi + + + else + headerok="yes" + fi + + if test $headerok = "yes"; then + if test -n "HAVE_OPENNET_H" -a -n "opennet.h"; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_OPENNET_H 1 +_ACEOF + + fi + if test -n "HAVE_LIBOPENNET" -a -n "fopen_net"; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_LIBOPENNET 1 +_ACEOF + + fi + LDFLAGS="$LIBSPECFLAGS $LDFLAGS" + if test -n "$LIBSPECLIBDIR"; then + + OLD_LDFLAGS="$LDFLAGS" + + LDRUNPATH="" + for testldflags in "-Wl,-rpath -Wl,$LIBSPECLIBDIR" "-Wl,-R -Wl,$LIBSPECLIBDIR"; do + LDFLAGS="$OLD_LDFLAGS $testldflags" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +int +main () +{ + return(0); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + LDRUNPATH="$LDRUNPATH $testldflags"; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext; + done + + LDFLAGS="$OLD_LDFLAGS" + if test -n "$LDRUNPATH"; then + LDFLAGS="$LDRUNPATH $LDFLAGS" + fi + + fi + LIBS="-lopennet $LIBS" + else + CFLAGS="$OLDCFLAGS" + CPPFLAGS="$OLDCPPFLAGS" + + { { echo "$as_me:$LINENO: error: Could not find opennet.h" >&5 +echo "$as_me: error: Could not find opennet.h" >&2;} + { (exit 1); exit 1; }; } + fi + +else + + { { echo "$as_me:$LINENO: error: Could not find opennet" >&5 +echo "$as_me: error: Could not find opennet" >&2;} + { (exit 1); exit 1; }; } + +fi + + ;; + esac + + + + LIBSPECLIBDIR="" + +# Check whether --with-libconfig or --without-libconfig was given. +if test "${with_libconfig+set}" = set; then + withval="$with_libconfig" + +# Specified + LIBSPEC=$withval + +else + +# Not specified + LIBSPECFLAGS="`pkg-config --libs libconfig 2>/dev/null`" + LIBSPECCFLAGS="`pkg-config --cflags libconfig 2>/dev/null`" + echo "$as_me:$LINENO: checking for lc_process in -lconfig" >&5 +echo $ECHO_N "checking for lc_process in -lconfig... $ECHO_C" >&6 +if test "${ac_cv_lib_config_lc_process+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lconfig $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lc_process (); +int +main () +{ +lc_process (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_config_lc_process=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_config_lc_process=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_config_lc_process" >&5 +echo "${ECHO_T}$ac_cv_lib_config_lc_process" >&6 +if test $ac_cv_lib_config_lc_process = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "libconfig.h" ; then + if test "${ac_cv_header_libconfig_h+set}" = set; then + echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking libconfig.h usability" >&5 +echo $ECHO_N "checking libconfig.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking libconfig.h presence" >&5 +echo $ECHO_N "checking libconfig.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: libconfig.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: libconfig.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: libconfig.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: libconfig.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_libconfig_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 + +fi +if test $ac_cv_header_libconfig_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + if test -n ""; then + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS=" $LIBSPECFLAGS" + echo "$as_me:$LINENO: checking for lc_process in -lconfig" >&5 +echo $ECHO_N "checking for lc_process in -lconfig... $ECHO_C" >&6 +if test "${ac_cv_lib_config_lc_process+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lconfig $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lc_process (); +int +main () +{ +lc_process (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_config_lc_process=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_config_lc_process=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_config_lc_process" >&5 +echo "${ECHO_T}$ac_cv_lib_config_lc_process" >&6 +if test $ac_cv_lib_config_lc_process = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "libconfig.h" ; then + if test "${ac_cv_header_libconfig_h+set}" = set; then + echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking libconfig.h usability" >&5 +echo $ECHO_N "checking libconfig.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking libconfig.h presence" >&5 +echo $ECHO_N "checking libconfig.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: libconfig.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: libconfig.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: libconfig.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: libconfig.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_libconfig_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 + +fi +if test $ac_cv_header_libconfig_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="" + echo "$as_me:$LINENO: checking for lc_process in -lconfig" >&5 +echo $ECHO_N "checking for lc_process in -lconfig... $ECHO_C" >&6 +if test "${ac_cv_lib_config_lc_process+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lconfig $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lc_process (); +int +main () +{ +lc_process (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_config_lc_process=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_config_lc_process=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_config_lc_process" >&5 +echo "${ECHO_T}$ac_cv_lib_config_lc_process" >&6 +if test $ac_cv_lib_config_lc_process = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "libconfig.h" ; then + if test "${ac_cv_header_libconfig_h+set}" = set; then + echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking libconfig.h usability" >&5 +echo $ECHO_N "checking libconfig.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking libconfig.h presence" >&5 +echo $ECHO_N "checking libconfig.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: libconfig.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: libconfig.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: libconfig.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: libconfig.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_libconfig_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 + +fi +if test $ac_cv_header_libconfig_h = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + LIBSPEC=no + + { { echo "$as_me:$LINENO: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&5 +echo "$as_me: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&2;} + { (exit 1); exit 1; }; } + + { echo "$as_me:$LINENO: WARNING: Did not find libconfig" >&5 +echo "$as_me: WARNING: Did not find libconfig" >&2;} + +fi + + +fi + + else + LIBSPEC=no + + { { echo "$as_me:$LINENO: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&5 +echo "$as_me: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&2;} + { (exit 1); exit 1; }; } + + { echo "$as_me:$LINENO: WARNING: Did not find libconfig" >&5 +echo "$as_me: WARNING: Did not find libconfig" >&2;} + fi + +fi + + +fi; + case $LIBSPEC in + no) + + { { echo "$as_me:$LINENO: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&5 +echo "$as_me: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&2;} + { (exit 1); exit 1; }; } + + { echo "$as_me:$LINENO: WARNING: Support for libconfig disabled" >&5 +echo "$as_me: WARNING: Support for libconfig disabled" >&2;} + ;; + *) + if test "${LIBSPEC}" = "yes"; then + true + else + LIBSPECLIBDIR="${LIBSPEC}/lib" + LIBSPECFLAGS="-L${LIBSPEC}/lib ${LIBSPECFLAGS}" + LIBSPECCFLAGS="-I${LIBSPEC}/include ${LIBSPECCFLAGS}" + fi + echo "$as_me:$LINENO: checking for lc_process in -lconfig" >&5 +echo $ECHO_N "checking for lc_process in -lconfig... $ECHO_C" >&6 +if test "${ac_cv_lib_config_lc_process+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lconfig $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char lc_process (); +int +main () +{ +lc_process (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_config_lc_process=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_config_lc_process=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_config_lc_process" >&5 +echo "${ECHO_T}$ac_cv_lib_config_lc_process" >&6 +if test $ac_cv_lib_config_lc_process = yes; then + + OLDCFLAGS="$CFLAGS" + OLDCPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS ${LIBSPECCFLAGS}" + CFLAGS="$CFLAGS ${LIBSPECCFLAGS}" + if test -n "libconfig.h"; then + if test "${ac_cv_header_libconfig_h+set}" = set; then + echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking libconfig.h usability" >&5 +echo $ECHO_N "checking libconfig.h usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking libconfig.h presence" >&5 +echo $ECHO_N "checking libconfig.h presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: libconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: libconfig.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: libconfig.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: libconfig.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: libconfig.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: libconfig.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: libconfig.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: libconfig.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: libconfig.h: in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for libconfig.h" >&5 +echo $ECHO_N "checking for libconfig.h... $ECHO_C" >&6 +if test "${ac_cv_header_libconfig_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_libconfig_h=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_libconfig_h" >&5 +echo "${ECHO_T}$ac_cv_header_libconfig_h" >&6 + +fi +if test $ac_cv_header_libconfig_h = yes; then + + headerok="yes" + +else + + headerok="no" + +fi + + + else + headerok="yes" + fi + + if test $headerok = "yes"; then + if test -n "HAVE_LIBCONFIG_H" -a -n "libconfig.h"; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_LIBCONFIG_H 1 +_ACEOF + + fi + if test -n "HAVE_LIBCONFIG" -a -n "lc_process"; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_LIBCONFIG 1 +_ACEOF + + fi + LDFLAGS="$LIBSPECFLAGS $LDFLAGS" + if test -n "$LIBSPECLIBDIR"; then + + OLD_LDFLAGS="$LDFLAGS" + + LDRUNPATH="" + for testldflags in "-Wl,-rpath -Wl,$LIBSPECLIBDIR" "-Wl,-R -Wl,$LIBSPECLIBDIR"; do + LDFLAGS="$OLD_LDFLAGS $testldflags" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +int +main () +{ + return(0); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + LDRUNPATH="$LDRUNPATH $testldflags"; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext; + done + + LDFLAGS="$OLD_LDFLAGS" + if test -n "$LDRUNPATH"; then + LDFLAGS="$LDRUNPATH $LDFLAGS" + fi + + fi + LIBS="-lconfig $LIBS" + else + CFLAGS="$OLDCFLAGS" + CPPFLAGS="$OLDCPPFLAGS" + + { { echo "$as_me:$LINENO: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&5 +echo "$as_me: error: Libconfig is required. http://www.rkeene.org/oss/libconfig/" >&2;} + { (exit 1); exit 1; }; } + + { { echo "$as_me:$LINENO: error: Could not find libconfig.h" >&5 +echo "$as_me: error: Could not find libconfig.h" >&2;} + { (exit 1); exit 1; }; } + fi + +else + + { { echo "$as_me:$LINENO: error: Could not find libconfig" >&5 +echo "$as_me: error: Could not find libconfig" >&2;} + { (exit 1); exit 1; }; } + +fi + + ;; + esac + + + + LIBSPECLIBDIR="" + +# Check whether --with-openssl or --without-openssl was given. +if test "${with_openssl+set}" = set; then + withval="$with_openssl" + +# Specified + LIBSPEC=$withval + +else + +# Not specified + LIBSPECFLAGS="`pkg-config --libs openssl 2>/dev/null`" + LIBSPECCFLAGS="`pkg-config --cflags openssl 2>/dev/null`" + echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5 +echo $ECHO_N "checking for SSL_library_init in -lssl... $ECHO_C" >&6 +if test "${ac_cv_lib_ssl_SSL_library_init+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lssl $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char SSL_library_init (); +int +main () +{ +SSL_library_init (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_ssl_SSL_library_init=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_ssl_SSL_library_init=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_library_init" >&5 +echo "${ECHO_T}$ac_cv_lib_ssl_SSL_library_init" >&6 +if test $ac_cv_lib_ssl_SSL_library_init = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "" ; then + if test "${ac_cv_header_+set}" = set; then + echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking usability" >&5 +echo $ECHO_N "checking usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking presence" >&5 +echo $ECHO_N "checking presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: : proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: : present but cannot be compiled" >&5 +echo "$as_me: WARNING: : present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: : check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: : check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: : see the Autoconf documentation" >&5 +echo "$as_me: WARNING: : see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: : section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: : section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: : proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: : in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: : in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 + +fi +if test $ac_cv_header_ = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + if test -n "-lwsock32 -lcrypto -lgdi32"; then + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="-lwsock32 -lcrypto -lgdi32 $LIBSPECFLAGS" + echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5 +echo $ECHO_N "checking for SSL_library_init in -lssl... $ECHO_C" >&6 +if test "${ac_cv_lib_ssl_SSL_library_init+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lssl $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char SSL_library_init (); +int +main () +{ +SSL_library_init (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_ssl_SSL_library_init=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_ssl_SSL_library_init=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_library_init" >&5 +echo "${ECHO_T}$ac_cv_lib_ssl_SSL_library_init" >&6 +if test $ac_cv_lib_ssl_SSL_library_init = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "" ; then + if test "${ac_cv_header_+set}" = set; then + echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking usability" >&5 +echo $ECHO_N "checking usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking presence" >&5 +echo $ECHO_N "checking presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: : proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: : present but cannot be compiled" >&5 +echo "$as_me: WARNING: : present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: : check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: : check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: : see the Autoconf documentation" >&5 +echo "$as_me: WARNING: : see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: : section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: : section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: : proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: : in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: : in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 + +fi +if test $ac_cv_header_ = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + unset `set | grep _cv_ | cut -f 1 -d =` + + LIBSPECFLAGS="-lwsock32 -lcrypto -lgdi32" + echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5 +echo $ECHO_N "checking for SSL_library_init in -lssl... $ECHO_C" >&6 +if test "${ac_cv_lib_ssl_SSL_library_init+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lssl $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char SSL_library_init (); +int +main () +{ +SSL_library_init (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_ssl_SSL_library_init=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_ssl_SSL_library_init=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_library_init" >&5 +echo "${ECHO_T}$ac_cv_lib_ssl_SSL_library_init" >&6 +if test $ac_cv_lib_ssl_SSL_library_init = yes; then + + OLDCPPFLAGS="$CPPFLAGS" + OLDCFLAGS="$CFLAGS" + CPPFLAGS="$CPPFLAGS $LIBSPECCFLAGS" + CFLAGS="$CFLAGS $LIBSPECCFLAGS" + if test -n "" ; then + if test "${ac_cv_header_+set}" = set; then + echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking usability" >&5 +echo $ECHO_N "checking usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking presence" >&5 +echo $ECHO_N "checking presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: : proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: : present but cannot be compiled" >&5 +echo "$as_me: WARNING: : present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: : check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: : check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: : see the Autoconf documentation" >&5 +echo "$as_me: WARNING: : see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: : section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: : section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: : proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: : in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: : in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 + +fi +if test $ac_cv_header_ = yes; then + + LIBSPEC=yes + +else + + LIBSPEC=no + +fi + + + fi + CPPFLAGS="$OLDCPPFLAGS" + CFLAGS="$OLDCFLAGS" + +else + + LIBSPEC=no + + { echo "$as_me:$LINENO: WARNING: Did not find openssl" >&5 +echo "$as_me: WARNING: Did not find openssl" >&2;} + +fi + + +fi + + else + LIBSPEC=no + + { echo "$as_me:$LINENO: WARNING: Did not find openssl" >&5 +echo "$as_me: WARNING: Did not find openssl" >&2;} + fi + +fi + + +fi; + case $LIBSPEC in + no) + + { echo "$as_me:$LINENO: WARNING: Support for openssl disabled" >&5 +echo "$as_me: WARNING: Support for openssl disabled" >&2;} + ;; + *) + if test "${LIBSPEC}" = "yes"; then + true + else + LIBSPECLIBDIR="${LIBSPEC}/lib" + LIBSPECFLAGS="-L${LIBSPEC}/lib ${LIBSPECFLAGS}" + LIBSPECCFLAGS="-I${LIBSPEC}/include ${LIBSPECCFLAGS}" + fi + echo "$as_me:$LINENO: checking for SSL_library_init in -lssl" >&5 +echo $ECHO_N "checking for SSL_library_init in -lssl... $ECHO_C" >&6 +if test "${ac_cv_lib_ssl_SSL_library_init+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lssl $LIBSPECFLAGS $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any gcc2 internal prototype to avoid an error. */ +#ifdef __cplusplus +extern "C" +#endif +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char SSL_library_init (); +int +main () +{ +SSL_library_init (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_lib_ssl_SSL_library_init=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_lib_ssl_SSL_library_init=no +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +echo "$as_me:$LINENO: result: $ac_cv_lib_ssl_SSL_library_init" >&5 +echo "${ECHO_T}$ac_cv_lib_ssl_SSL_library_init" >&6 +if test $ac_cv_lib_ssl_SSL_library_init = yes; then + + OLDCFLAGS="$CFLAGS" + OLDCPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS ${LIBSPECCFLAGS}" + CFLAGS="$CFLAGS ${LIBSPECCFLAGS}" + if test -n ""; then + if test "${ac_cv_header_+set}" = set; then + echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 +else + # Is the header compilable? +echo "$as_me:$LINENO: checking usability" >&5 +echo $ECHO_N "checking usability... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include <> +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_header_compiler=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6 + +# Is the header present? +echo "$as_me:$LINENO: checking presence" >&5 +echo $ECHO_N "checking presence... $ECHO_C" >&6 +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include <> +_ACEOF +if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5 + (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null; then + if test -s conftest.err; then + ac_cpp_err=$ac_c_preproc_warn_flag + ac_cpp_err=$ac_cpp_err$ac_c_werror_flag + else + ac_cpp_err= + fi +else + ac_cpp_err=yes +fi +if test -z "$ac_cpp_err"; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi +rm -f conftest.err conftest.$ac_ext +echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6 + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: : accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: : proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: : present but cannot be compiled" >&5 +echo "$as_me: WARNING: : present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: : check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: : check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: : see the Autoconf documentation" >&5 +echo "$as_me: WARNING: : see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: : section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: : section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: : proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: : proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: : in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: : in the future, the compiler will take precedence" >&2;} + ( + cat <<\_ASBOX +## ------------------------------------ ## +## Report this to the backuppcd lists. ## +## ------------------------------------ ## +_ASBOX + ) | + sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +echo "$as_me:$LINENO: checking for " >&5 +echo $ECHO_N "checking for ... $ECHO_C" >&6 +if test "${ac_cv_header_+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_=$ac_header_preproc +fi +echo "$as_me:$LINENO: result: $ac_cv_header_" >&5 +echo "${ECHO_T}$ac_cv_header_" >&6 + +fi +if test $ac_cv_header_ = yes; then + + headerok="yes" + +else + + headerok="no" + +fi + + + else + headerok="yes" + fi + + if test $headerok = "yes"; then + if test -n "THIS_MAKES_STUPID_AUTOHEADER_HAPPY" -a -n ""; then + +cat >>confdefs.h <<\_ACEOF +#define THIS_MAKES_STUPID_AUTOHEADER_HAPPY 1 +_ACEOF + + fi + if test -n "HAVE_LIBSSL" -a -n "SSL_library_init"; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_LIBSSL 1 +_ACEOF + + fi + LDFLAGS="$LIBSPECFLAGS $LDFLAGS" + if test -n "$LIBSPECLIBDIR"; then + + OLD_LDFLAGS="$LDFLAGS" + + LDRUNPATH="" + for testldflags in "-Wl,-rpath -Wl,$LIBSPECLIBDIR" "-Wl,-R -Wl,$LIBSPECLIBDIR"; do + LDFLAGS="$OLD_LDFLAGS $testldflags" + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +int +main () +{ + return(0); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + LDRUNPATH="$LDRUNPATH $testldflags"; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext; + done + + LDFLAGS="$OLD_LDFLAGS" + if test -n "$LDRUNPATH"; then + LDFLAGS="$LDRUNPATH $LDFLAGS" + fi + + fi + LIBS="-lssl $LIBS" + else + CFLAGS="$OLDCFLAGS" + CPPFLAGS="$OLDCPPFLAGS" + + { { echo "$as_me:$LINENO: error: Could not find " >&5 +echo "$as_me: error: Could not find " >&2;} + { (exit 1); exit 1; }; } + fi + +else + + { { echo "$as_me:$LINENO: error: Could not find openssl" >&5 +echo "$as_me: error: Could not find openssl" >&2;} + { (exit 1); exit 1; }; } + +fi + + ;; + esac + + + +# Check whether --with-nt4 or --without-nt4 was given. +if test "${with_nt4+set}" = set; then + withval="$with_nt4" + winntfoursupport=$withval +else + winntfoursupport=no +fi; +if test "$winntfoursupport" = "no"; then + +cat >>confdefs.h <<\_ACEOF +#define NO_WIN32_NT4 1 +_ACEOF + +fi + + +# Check whether --with-masterpw or --without-masterpw was given. +if test "${with_masterpw+set}" = set; then + withval="$with_masterpw" + masterpw=$withval +else + masterpw=no +fi; +if test "$masterpw" != "no"; then + if test "$masterpw" = "yes"; then + { { echo "$as_me:$LINENO: error: Master password must be specified on the command line." >&5 +echo "$as_me: error: Master password must be specified on the command line." >&2;} + { (exit 1); exit 1; }; } + fi + +cat >>confdefs.h <<_ACEOF +#define BPC_CONF_MASTER_PASSWORD "$masterpw" +_ACEOF + +fi + + +# Check whether --with-updateurl or --without-updateurl was given. +if test "${with_updateurl+set}" = set; then + withval="$with_updateurl" + updateurl="$withval" +else + updateurl=no +fi; +if test "$updateurl" != "no"; then + if test "$updateurl" = "yes"; then + { { echo "$as_me:$LINENO: error: URL must be specified on the command line." >&5 +echo "$as_me: error: URL must be specified on the command line." >&2;} + { (exit 1); exit 1; }; } + fi + +cat >>confdefs.h <<_ACEOF +#define BPC_CONF_UPDATEURL "$updateurl" +_ACEOF + +fi + + +# Check whether --with-notifyserv or --without-notifyserv was given. +if test "${with_notifyserv+set}" = set; then + withval="$with_notifyserv" + notifyserv="$withval" +else + notifyserv=no +fi; +if test "$notifyserv" != "no"; then + if test "$notifyserv" = "yes"; then + { { echo "$as_me:$LINENO: error: Notification server must be specified on the command line." >&5 +echo "$as_me: error: Notification server must be specified on the command line." >&2;} + { (exit 1); exit 1; }; } + fi + +cat >>confdefs.h <<_ACEOF +#define BPC_CONF_NOTIFYSERV "$notifyserv" +_ACEOF + +fi + +# Check whether --enable-debug or --disable-debug was given. +if test "${enable_debug+set}" = set; then + enableval="$enable_debug" + debugenabled=$enableval +else + debugenabled=no +fi; +if test "$debugenabled" = "no"; then + +cat >>confdefs.h <<\_ACEOF +#define NDEBUG 1 +_ACEOF + +else + +cat >>confdefs.h <<\_ACEOF +#define DEBUG 1 +_ACEOF + +fi + +echo "$as_me:$LINENO: checking whether byte ordering is bigendian" >&5 +echo $ECHO_N "checking whether byte ordering is bigendian... $ECHO_C" >&6 +if test "${ac_cv_c_bigendian+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + # See if sys/param.h defines the BYTE_ORDER macro. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +int +main () +{ +#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN + bogus endian macros +#endif + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + # It does; now see whether it defined to BIG_ENDIAN or not. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +#include + +int +main () +{ +#if BYTE_ORDER != BIG_ENDIAN + not big endian +#endif + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_bigendian=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_c_bigendian=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +# It does not; compile a test program. +if test "$cross_compiling" = yes; then + # try to guess the endianness by grepping values into an object file + ac_cv_c_bigendian=unknown + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; +short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; +void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; } +short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; +short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; +void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; } +int +main () +{ + _ascii (); _ebcdic (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then + ac_cv_c_bigendian=yes +fi +if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then + if test "$ac_cv_c_bigendian" = unknown; then + ac_cv_c_bigendian=no + else + # finding both strings is unlikely to happen, but who knows? + ac_cv_c_bigendian=unknown + fi +fi +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +int +main () +{ + /* Are we little or big endian? From Harbison&Steele. */ + union + { + long l; + char c[sizeof (long)]; + } u; + u.l = 1; + exit (u.c[sizeof (long) - 1] == 1); +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_c_bigendian=no +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +ac_cv_c_bigendian=yes +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_c_bigendian" >&5 +echo "${ECHO_T}$ac_cv_c_bigendian" >&6 +case $ac_cv_c_bigendian in + yes) + +cat >>confdefs.h <<\_ACEOF +#define WORDS_BIGENDIAN 1 +_ACEOF + ;; + no) + ;; + *) + + +cat >>confdefs.h <<\_ACEOF +#define ENDIAN_UNKNOWN 1 +_ACEOF + + ;; +esac + + +# Check whether --enable-static or --disable-static was given. +if test "${enable_static+set}" = set; then + enableval="$enable_static" + staticbuild=$enableval +else + staticbuild=no +fi; +if test ! "$staticbuild" = "no"; then + + + + NEWLIBS="" + NEWLDFLAGS="" + + rm -f conftest conftest.c + cat <<\_ACEOF > conftest.c +#include +int main(void) { return(0); } +_ACEOF + "$CC" -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.c $LIBS >/dev/null 2>/dev/null + if test -e conftest; then + if test -z "$LDD"; then + LDD=`echo "$CC" | sed 's@gcc$@ldd@'` + if test "$LDD" = "$CC"; then + LDD=`echo "$CC" | sed 's@cc$@ldd@'` + fi + if test "$LDD" = "$CC"; then + LDD=false + fi + fi + "$LDD" conftest 2>/dev/null >conftest.ldd + fi + rm -f conftest conftest.c + + if test -e conftest.ldd; then + for lib in $LIBS; do + if echo "$lib" | grep '\-l' >/dev/null; then + libname=`echo "$lib" | sed 's@^-l@@'` + testlib=`cat conftest.ldd | awk '{ print $3 }' | sed 's@\..*$@@' | grep "/lib$libname$"`.a + if test -e "$testlib" -a -n "$testlib"; then + lib="$testlib" + fi + fi + NEWLIBS="$NEWLIBS $lib" + done + for lib in $LDFLAGS; do + if echo "$lib" | grep '\-l' >/dev/null; then + libname=`echo "$lib" | sed 's@^-l@@'` + testlib=`cat conftest.ldd | awk '{ print $3 }' | sed 's@\..*$@@' | grep "/lib$libname$"`.a + if test -e "$testlib" -a -n "$testlib"; then + lib="$testlib" + fi + fi + NEWLDFLAGS="$NEWLDFLAGS $lib" + done + + LIBS="$NEWLIBS" + LDFLAGS="$NEWLDFLAGS" + fi + + rm -f conftest.ldd + +fi + + + ac_config_files="$ac_config_files Makefile" +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, don't put newlines in cache variables' values. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +{ + (set) 2>&1 | + case `(ac_space=' '; set | grep ac_space) 2>&1` in + *ac_space=\ *) + # `set' does not quote correctly, so add quotes (double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \). + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n \ + "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" + ;; + esac; +} | + sed ' + t clear + : clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + : end' >>confcache +if diff $cache_file confcache >/dev/null 2>&1; then :; else + if test -w $cache_file; then + test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" + cat confcache >$cache_file + else + echo "not updating unwritable cache $cache_file" + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +# VPATH may cause trouble with some makes, so we remove $(srcdir), +# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=/{ +s/:*\$(srcdir):*/:/; +s/:*\${srcdir}:*/:/; +s/:*@srcdir@:*/:/; +s/^\([^=]*=[ ]*\):*/\1/; +s/:*$//; +s/^[^=]*=[ ]*$//; +}' +fi + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_i=`echo "$ac_i" | + sed 's/\$U\././;s/\.o$//;s/\.obj$//'` + # 2. Add them. + ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext" + ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + + +: ${CONFIG_STATUS=./config.status} +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 +echo "$as_me: creating $CONFIG_STATUS" >&6;} +cat >$CONFIG_STATUS <<_ACEOF +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false +SHELL=\${CONFIG_SHELL-$SHELL} +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF +## --------------------- ## +## M4sh Initialization. ## +## --------------------- ## + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' +elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then + set -o posix +fi +DUALCASE=1; export DUALCASE # for MKS sh + +# Support unset when possible. +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + as_unset=unset +else + as_unset=false +fi + + +# Work around bugs in pre-3.0 UWIN ksh. +$as_unset ENV MAIL MAILPATH +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +for as_var in \ + LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ + LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ + LC_TELEPHONE LC_TIME +do + if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then + eval $as_var=C; export $as_var + else + $as_unset $as_var + fi +done + +# Required to use basename. +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + + +# Name of the executable. +as_me=`$as_basename "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)$' \| \ + . : '\(.\)' 2>/dev/null || +echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } + /^X\/\(\/\/\)$/{ s//\1/; q; } + /^X\/\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + + +# PATH needs CR, and LINENO needs CR and PATH. +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + echo "#! /bin/sh" >conf$$.sh + echo "exit 0" >>conf$$.sh + chmod +x conf$$.sh + if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then + PATH_SEPARATOR=';' + else + PATH_SEPARATOR=: + fi + rm -f conf$$.sh +fi + + + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" || { + # Find who we are. Look in the path if we contain no path at all + # relative or not. + case $0 in + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break +done + + ;; + esac + # We did not find ourselves, most probably we were run as `sh COMMAND' + # in which case we are not to be found in the path. + if test "x$as_myself" = x; then + as_myself=$0 + fi + if test ! -f "$as_myself"; then + { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5 +echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;} + { (exit 1); exit 1; }; } + fi + case $CONFIG_SHELL in + '') + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for as_base in sh bash ksh sh5; do + case $as_dir in + /*) + if ("$as_dir/$as_base" -c ' + as_lineno_1=$LINENO + as_lineno_2=$LINENO + as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` + test "x$as_lineno_1" != "x$as_lineno_2" && + test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then + $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } + $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } + CONFIG_SHELL=$as_dir/$as_base + export CONFIG_SHELL + exec "$CONFIG_SHELL" "$0" ${1+"$@"} + fi;; + esac + done +done +;; + esac + + # Create $as_me.lineno as a copy of $as_myself, but with $LINENO + # uniformly replaced by the line number. The first 'sed' inserts a + # line-number line before each line; the second 'sed' does the real + # work. The second script uses 'N' to pair each line-number line + # with the numbered line, and appends trailing '-' during + # substitution so that $LINENO is not a special case at line end. + # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the + # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) + sed '=' <$as_myself | + sed ' + N + s,$,-, + : loop + s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, + t loop + s,-$,, + s,^['$as_cr_digits']*\n,, + ' >$as_me.lineno && + chmod +x $as_me.lineno || + { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5 +echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;} + { (exit 1); exit 1; }; } + + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensible to this). + . ./$as_me.lineno + # Exit status is that of the last command. + exit +} + + +case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in + *c*,-n*) ECHO_N= ECHO_C=' +' ECHO_T=' ' ;; + *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; + *) ECHO_N= ECHO_C='\c' ECHO_T= ;; +esac + +if expr a : '\(a\)' >/dev/null 2>&1; then + as_expr=expr +else + as_expr=false +fi + +rm -f conf$$ conf$$.exe conf$$.file +echo >conf$$.file +if ln -s conf$$.file conf$$ 2>/dev/null; then + # We could just check for DJGPP; but this test a) works b) is more generic + # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). + if test -f conf$$.exe; then + # Don't use ln at all; we don't have any links + as_ln_s='cp -p' + else + as_ln_s='ln -s' + fi +elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln +else + as_ln_s='cp -p' +fi +rm -f conf$$ conf$$.exe conf$$.file + +if mkdir -p . 2>/dev/null; then + as_mkdir_p=: +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_executable_p="test -f" + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +# IFS +# We need space, tab and new line, in precisely that order. +as_nl=' +' +IFS=" $as_nl" + +# CDPATH. +$as_unset CDPATH + +exec 6>&1 + +# Open the log real soon, to keep \$[0] and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. Logging --version etc. is OK. +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX +} >&5 +cat >&5 <<_CSEOF + +This file was extended by backuppcd $as_me 0.1.3, which was +generated by GNU Autoconf 2.59. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +_CSEOF +echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5 +echo >&5 +_ACEOF + +# Files that config.status was made for. +if test -n "$ac_config_files"; then + echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_headers"; then + echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_links"; then + echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS +fi + +if test -n "$ac_config_commands"; then + echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS +fi + +cat >>$CONFIG_STATUS <<\_ACEOF + +ac_cs_usage="\ +\`$as_me' instantiates files from templates according to the +current configuration. + +Usage: $0 [OPTIONS] [FILE]... + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Report bugs to ." +_ACEOF + +cat >>$CONFIG_STATUS <<_ACEOF +ac_cs_version="\\ +backuppcd config.status 0.1.3 +configured by $0, generated by GNU Autoconf 2.59, + with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" + +Copyright (C) 2003 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." +srcdir=$srcdir +INSTALL="$INSTALL" +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF +# If no file are specified by the user, then we need to provide default +# value. By we need to know if files were specified by the user. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=*) + ac_option=`expr "x$1" : 'x\([^=]*\)='` + ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` + ac_shift=: + ;; + -*) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + *) # This is not an option, so the user has probably given explicit + # arguments. + ac_option=$1 + ac_need_defaults=false;; + esac + + case $ac_option in + # Handling of the options. +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --vers* | -V ) + echo "$ac_cs_version"; exit 0 ;; + --he | --h) + # Conflict between --help and --header + { { echo "$as_me:$LINENO: error: ambiguous option: $1 +Try \`$0 --help' for more information." >&5 +echo "$as_me: error: ambiguous option: $1 +Try \`$0 --help' for more information." >&2;} + { (exit 1); exit 1; }; };; + --help | --hel | -h ) + echo "$ac_cs_usage"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + CONFIG_FILES="$CONFIG_FILES $ac_optarg" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" + ac_need_defaults=false;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1 +Try \`$0 --help' for more information." >&5 +echo "$as_me: error: unrecognized option: $1 +Try \`$0 --help' for more information." >&2;} + { (exit 1); exit 1; }; } ;; + + *) ac_config_targets="$ac_config_targets $1" ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF +if \$ac_cs_recheck; then + echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 + exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion +fi + +_ACEOF + + + + + +cat >>$CONFIG_STATUS <<\_ACEOF +for ac_config_target in $ac_config_targets +do + case "$ac_config_target" in + # Handling of arguments. + "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; + *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 +echo "$as_me: error: invalid argument: $ac_config_target" >&2;} + { (exit 1); exit 1; }; };; + esac +done + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason to put it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Create a temporary directory, and hook for its removal unless debugging. +$debug || +{ + trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 + trap '{ (exit 1); exit 1; }' 1 2 13 15 +} + +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` && + test -n "$tmp" && test -d "$tmp" +} || +{ + tmp=./confstat$$-$RANDOM + (umask 077 && mkdir $tmp) +} || +{ + echo "$me: cannot create a temporary directory in ." >&2 + { (exit 1); exit 1; } +} + +_ACEOF + +cat >>$CONFIG_STATUS <<_ACEOF + +# +# CONFIG_FILES section. +# + +# No need to generate the scripts if there are no CONFIG_FILES. +# This happens for instance when ./config.status config.h +if test -n "\$CONFIG_FILES"; then + # Protect against being on the right side of a sed subst in config.status. + sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g; + s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF +s,@SHELL@,$SHELL,;t t +s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t +s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t +s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t +s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t +s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t +s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t +s,@exec_prefix@,$exec_prefix,;t t +s,@prefix@,$prefix,;t t +s,@program_transform_name@,$program_transform_name,;t t +s,@bindir@,$bindir,;t t +s,@sbindir@,$sbindir,;t t +s,@libexecdir@,$libexecdir,;t t +s,@datadir@,$datadir,;t t +s,@sysconfdir@,$sysconfdir,;t t +s,@sharedstatedir@,$sharedstatedir,;t t +s,@localstatedir@,$localstatedir,;t t +s,@libdir@,$libdir,;t t +s,@includedir@,$includedir,;t t +s,@oldincludedir@,$oldincludedir,;t t +s,@infodir@,$infodir,;t t +s,@mandir@,$mandir,;t t +s,@build_alias@,$build_alias,;t t +s,@host_alias@,$host_alias,;t t +s,@target_alias@,$target_alias,;t t +s,@DEFS@,$DEFS,;t t +s,@ECHO_C@,$ECHO_C,;t t +s,@ECHO_N@,$ECHO_N,;t t +s,@ECHO_T@,$ECHO_T,;t t +s,@LIBS@,$LIBS,;t t +s,@build@,$build,;t t +s,@build_cpu@,$build_cpu,;t t +s,@build_vendor@,$build_vendor,;t t +s,@build_os@,$build_os,;t t +s,@host@,$host,;t t +s,@host_cpu@,$host_cpu,;t t +s,@host_vendor@,$host_vendor,;t t +s,@host_os@,$host_os,;t t +s,@CFLAGS@,$CFLAGS,;t t +s,@CPPFLAGS@,$CPPFLAGS,;t t +s,@AREXT@,$AREXT,;t t +s,@CC@,$CC,;t t +s,@LDFLAGS@,$LDFLAGS,;t t +s,@ac_ct_CC@,$ac_ct_CC,;t t +s,@EXEEXT@,$EXEEXT,;t t +s,@OBJEXT@,$OBJEXT,;t t +s,@SET_MAKE@,$SET_MAKE,;t t +s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t +s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t +s,@INSTALL_DATA@,$INSTALL_DATA,;t t +s,@RANLIB@,$RANLIB,;t t +s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t +s,@CPP@,$CPP,;t t +s,@EGREP@,$EGREP,;t t +s,@AR@,$AR,;t t +s,@ac_ct_AR@,$ac_ct_AR,;t t +s,@LIBOBJS@,$LIBOBJS,;t t +s,@LTLIBOBJS@,$LTLIBOBJS,;t t +CEOF + +_ACEOF + + cat >>$CONFIG_STATUS <<\_ACEOF + # Split the substitutions into bite-sized pieces for seds with + # small command number limits, like on Digital OSF/1 and HP-UX. + ac_max_sed_lines=48 + ac_sed_frag=1 # Number of current file. + ac_beg=1 # First line for current file. + ac_end=$ac_max_sed_lines # Line after last line for current file. + ac_more_lines=: + ac_sed_cmds= + while $ac_more_lines; do + if test $ac_beg -gt 1; then + sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag + else + sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag + fi + if test ! -s $tmp/subs.frag; then + ac_more_lines=false + else + # The purpose of the label and of the branching condition is to + # speed up the sed processing (if there are no `@' at all, there + # is no need to browse any of the substitutions). + # These are the two extra sed commands mentioned above. + (echo ':t + /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed + if test -z "$ac_sed_cmds"; then + ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" + else + ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" + fi + ac_sed_frag=`expr $ac_sed_frag + 1` + ac_beg=$ac_end + ac_end=`expr $ac_end + $ac_max_sed_lines` + fi + done + if test -z "$ac_sed_cmds"; then + ac_sed_cmds=cat + fi +fi # test -n "$CONFIG_FILES" + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF +for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case $ac_file in + - | *:- | *:-:* ) # input from stdin + cat >$tmp/stdin + ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + * ) ac_file_in=$ac_file.in ;; + esac + + # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. + ac_dir=`(dirname "$ac_file") 2>/dev/null || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + { if $as_mkdir_p; then + mkdir -p "$ac_dir" + else + as_dir="$ac_dir" + as_dirs= + while test ! -d "$as_dir"; do + as_dirs="$as_dir $as_dirs" + as_dir=`(dirname "$as_dir") 2>/dev/null || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + done + test ! -n "$as_dirs" || mkdir $as_dirs + fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 +echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} + { (exit 1); exit 1; }; }; } + + ac_builddir=. + +if test "$ac_dir" != .; then + ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` + # A "../" for each directory in $ac_dir_suffix. + ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` +else + ac_dir_suffix= ac_top_builddir= +fi + +case $srcdir in + .) # No --srcdir option. We are building in place. + ac_srcdir=. + if test -z "$ac_top_builddir"; then + ac_top_srcdir=. + else + ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` + fi ;; + [\\/]* | ?:[\\/]* ) # Absolute path. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir ;; + *) # Relative path. + ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_builddir$srcdir ;; +esac + +# Do not use `cd foo && pwd` to compute absolute paths, because +# the directories may not exist. +case `pwd` in +.) ac_abs_builddir="$ac_dir";; +*) + case "$ac_dir" in + .) ac_abs_builddir=`pwd`;; + [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";; + *) ac_abs_builddir=`pwd`/"$ac_dir";; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_top_builddir=${ac_top_builddir}.;; +*) + case ${ac_top_builddir}. in + .) ac_abs_top_builddir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;; + *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_srcdir=$ac_srcdir;; +*) + case $ac_srcdir in + .) ac_abs_srcdir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;; + *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;; + esac;; +esac +case $ac_abs_builddir in +.) ac_abs_top_srcdir=$ac_top_srcdir;; +*) + case $ac_top_srcdir in + .) ac_abs_top_srcdir=$ac_abs_builddir;; + [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;; + *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;; + esac;; +esac + + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_builddir$INSTALL ;; + esac + + if test x"$ac_file" != x-; then + { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + rm -f "$ac_file" + fi + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + if test x"$ac_file" = x-; then + configure_input= + else + configure_input="$ac_file. " + fi + configure_input=$configure_input"Generated from `echo $ac_file_in | + sed 's,.*/,,'` by configure." + + # First look for the input files in the build tree, otherwise in the + # src tree. + ac_file_inputs=`IFS=: + for f in $ac_file_in; do + case $f in + -) echo $tmp/stdin ;; + [\\/$]*) + # Absolute (can't be DOS-style, as IFS=:) + test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + echo "$f";; + *) # Relative + if test -f "$f"; then + # Build tree + echo "$f" + elif test -f "$srcdir/$f"; then + # Source tree + echo "$srcdir/$f" + else + # /dev/null tree + { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + fi;; + esac + done` || { (exit 1); exit 1; } +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF + sed "$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s,@configure_input@,$configure_input,;t t +s,@srcdir@,$ac_srcdir,;t t +s,@abs_srcdir@,$ac_abs_srcdir,;t t +s,@top_srcdir@,$ac_top_srcdir,;t t +s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t +s,@builddir@,$ac_builddir,;t t +s,@abs_builddir@,$ac_abs_builddir,;t t +s,@top_builddir@,$ac_top_builddir,;t t +s,@abs_top_builddir@,$ac_abs_top_builddir,;t t +s,@INSTALL@,$ac_INSTALL,;t t +" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out + rm -f $tmp/stdin + if test x"$ac_file" != x-; then + mv $tmp/out $ac_file + else + cat $tmp/out + rm -f $tmp/out + fi + +done +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF + +# +# CONFIG_HEADER section. +# + +# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where +# NAME is the cpp macro being defined and VALUE is the value it is being given. +# +# ac_d sets the value in "#define NAME VALUE" lines. +ac_dA='s,^\([ ]*\)#\([ ]*define[ ][ ]*\)' +ac_dB='[ ].*$,\1#\2' +ac_dC=' ' +ac_dD=',;t' +# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE". +ac_uA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_uB='$,\1#\2define\3' +ac_uC=' ' +ac_uD=',;t' + +for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case $ac_file in + - | *:- | *:-:* ) # input from stdin + cat >$tmp/stdin + ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` + ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; + * ) ac_file_in=$ac_file.in ;; + esac + + test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + + # First look for the input files in the build tree, otherwise in the + # src tree. + ac_file_inputs=`IFS=: + for f in $ac_file_in; do + case $f in + -) echo $tmp/stdin ;; + [\\/$]*) + # Absolute (can't be DOS-style, as IFS=:) + test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + # Do quote $f, to prevent DOS paths from being IFS'd. + echo "$f";; + *) # Relative + if test -f "$f"; then + # Build tree + echo "$f" + elif test -f "$srcdir/$f"; then + # Source tree + echo "$srcdir/$f" + else + # /dev/null tree + { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 +echo "$as_me: error: cannot find input file: $f" >&2;} + { (exit 1); exit 1; }; } + fi;; + esac + done` || { (exit 1); exit 1; } + # Remove the trailing spaces. + sed 's/[ ]*$//' $ac_file_inputs >$tmp/in + +_ACEOF + +# Transform confdefs.h into two sed scripts, `conftest.defines' and +# `conftest.undefs', that substitutes the proper values into +# config.h.in to produce config.h. The first handles `#define' +# templates, and the second `#undef' templates. +# And first: Protect against being on the right side of a sed subst in +# config.status. Protect against being in an unquoted here document +# in config.status. +rm -f conftest.defines conftest.undefs +# Using a here document instead of a string reduces the quoting nightmare. +# Putting comments in sed scripts is not portable. +# +# `end' is used to avoid that the second main sed command (meant for +# 0-ary CPP macros) applies to n-ary macro definitions. +# See the Autoconf documentation for `clear'. +cat >confdef2sed.sed <<\_ACEOF +s/[\\&,]/\\&/g +s,[\\$`],\\&,g +t clear +: clear +s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*\)\(([^)]*)\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp +t end +s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp +: end +_ACEOF +# If some macros were called several times there might be several times +# the same #defines, which is useless. Nevertheless, we may not want to +# sort them, since we want the *last* AC-DEFINE to be honored. +uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines +sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs +rm -f confdef2sed.sed + +# This sed command replaces #undef with comments. This is necessary, for +# example, in the case of _POSIX_SOURCE, which is predefined and required +# on some systems where configure will not decide to define it. +cat >>conftest.undefs <<\_ACEOF +s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, +_ACEOF + +# Break up conftest.defines because some shells have a limit on the size +# of here documents, and old seds have small limits too (100 cmds). +echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS +echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS +echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS +echo ' :' >>$CONFIG_STATUS +rm -f conftest.tail +while grep . conftest.defines >/dev/null +do + # Write a limited-size here document to $tmp/defines.sed. + echo ' cat >$tmp/defines.sed <>$CONFIG_STATUS + # Speed up: don't consider the non `#define' lines. + echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS + # Work around the forget-to-reset-the-flag bug. + echo 't clr' >>$CONFIG_STATUS + echo ': clr' >>$CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS + echo 'CEOF + sed -f $tmp/defines.sed $tmp/in >$tmp/out + rm -f $tmp/in + mv $tmp/out $tmp/in +' >>$CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail + rm -f conftest.defines + mv conftest.tail conftest.defines +done +rm -f conftest.defines +echo ' fi # grep' >>$CONFIG_STATUS +echo >>$CONFIG_STATUS + +# Break up conftest.undefs because some shells have a limit on the size +# of here documents, and old seds have small limits too (100 cmds). +echo ' # Handle all the #undef templates' >>$CONFIG_STATUS +rm -f conftest.tail +while grep . conftest.undefs >/dev/null +do + # Write a limited-size here document to $tmp/undefs.sed. + echo ' cat >$tmp/undefs.sed <>$CONFIG_STATUS + # Speed up: don't consider the non `#undef' + echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS + # Work around the forget-to-reset-the-flag bug. + echo 't clr' >>$CONFIG_STATUS + echo ': clr' >>$CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS + echo 'CEOF + sed -f $tmp/undefs.sed $tmp/in >$tmp/out + rm -f $tmp/in + mv $tmp/out $tmp/in +' >>$CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail + rm -f conftest.undefs + mv conftest.tail conftest.undefs +done +rm -f conftest.undefs + +cat >>$CONFIG_STATUS <<\_ACEOF + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + if test x"$ac_file" = x-; then + echo "/* Generated by configure. */" >$tmp/config.h + else + echo "/* $ac_file. Generated by configure. */" >$tmp/config.h + fi + cat $tmp/in >>$tmp/config.h + rm -f $tmp/in + if test x"$ac_file" != x-; then + if diff $ac_file $tmp/config.h >/dev/null 2>&1; then + { echo "$as_me:$LINENO: $ac_file is unchanged" >&5 +echo "$as_me: $ac_file is unchanged" >&6;} + else + ac_dir=`(dirname "$ac_file") 2>/dev/null || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + { if $as_mkdir_p; then + mkdir -p "$ac_dir" + else + as_dir="$ac_dir" + as_dirs= + while test ! -d "$as_dir"; do + as_dirs="$as_dir $as_dirs" + as_dir=`(dirname "$as_dir") 2>/dev/null || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| \ + . : '\(.\)' 2>/dev/null || +echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } + /^X\(\/\/\)[^/].*/{ s//\1/; q; } + /^X\(\/\/\)$/{ s//\1/; q; } + /^X\(\/\).*/{ s//\1/; q; } + s/.*/./; q'` + done + test ! -n "$as_dirs" || mkdir $as_dirs + fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 +echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} + { (exit 1); exit 1; }; }; } + + rm -f $ac_file + mv $tmp/config.h $ac_file + fi + else + cat $tmp/config.h + rm -f $tmp/config.h + fi +done +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF + +{ (exit 0); exit 0; } +_ACEOF +chmod +x $CONFIG_STATUS +ac_clean_files=$ac_clean_files_save + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || { (exit 1); exit 1; } +fi + diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..3423e0d --- /dev/null +++ b/configure.ac @@ -0,0 +1,97 @@ +AC_REVISION($Revision $) +AC_INIT(backuppcd, 0.1.3) +AC_CONFIG_HEADER(config.h) + +dnl Check OS info +DC_CHK_OS_INFO + +dnl Checks for programs. +AC_PROG_CC +AC_PROG_MAKE_SET +AC_PROG_INSTALL +AC_PROG_RANLIB +AC_AIX +AC_GNU_SOURCE +AC_CHECK_TOOL(AR, ar, true) + +AC_CHECK_HEADERS(stdlib.h string.h unistd.h time.h sys/time.h sys/types.h signal.h syslog.h sys/select.h netinet/in.h arpa/inet.h sys/socket.h ssl.h openssl/ssl.h ssl/ssl.h fcntl.h dirent.h ctype.h assert.h endian.h stdarg.h utime.h fnmatch.h sys/vfs.h sys/statfs.h sys/param.h sys/mount.h sys/resource.h limits.h) +AC_HEADER_TIME +AC_CHECK_FUNCS(sysinfo openlog syslog setsid fork fcntl stat lstat lchown symlink readlink signal getenv utime statfs getmntinfo setpriority) +AC_REPLACE_FUNCS(htonll ntohll chown link fnmatch strsep gethostname) + +DC_DO_NETWORK + +dnl Check for various types we use +DC_DO_TYPE(uint64_t, unsigned, 8) +DC_DO_TYPE(int64_t, signed, 8) +DC_DO_TYPE(uint32_t, unsigned, 4) +DC_DO_TYPE(int32_t, signed, 4) +DC_DO_TYPE(uint16_t, unsigned, 2) +DC_DO_TYPE(int16_t, signed, 2) +AC_TYPE_UID_T + +dnl Checks for Win32 specific things. +DC_DO_WIN32 + +dnl Large file support +AC_SYS_LARGEFILE +AC_FUNC_FSEEKO +AC_TYPE_OFF_T + +dnl Check for libopennet +DC_ASK_OPTLIB(opennet, fopen_net,opennet.h, [Support opennet (required for automatic updates)], opennet, HAVE_LIBOPENNET, HAVE_OPENNET_H) + +dnl Check for libconfig +DC_ASK_OPTLIB(config, lc_process, libconfig.h, [Process configuration files using libconfig], libconfig, HAVE_LIBCONFIG, HAVE_LIBCONFIG_H,, [ + AC_MSG_ERROR([Libconfig is required. http://www.rkeene.org/oss/libconfig/]) +]) + +DC_ASK_OPTLIB(ssl, SSL_library_init,, [Allow encrypted connections using SSL], openssl, HAVE_LIBSSL, THIS_MAKES_STUPID_AUTOHEADER_HAPPY, [-lwsock32 -lcrypto -lgdi32]) + +AC_ARG_WITH(nt4, AC_HELP_STRING([--with-nt4], [Enable support for Windows NT 4 (only applies for Windows)]), [ winntfoursupport=$withval ], [ winntfoursupport=no ]) +if test "$winntfoursupport" = "no"; then + AC_DEFINE(NO_WIN32_NT4, [1], [Define if you wish to disallow support for Windows NT 4]) +fi + +AC_ARG_WITH(masterpw, AC_HELP_STRING([--with-masterpw], [Enable support for a hard-coded master password]), [ masterpw=$withval ], [ masterpw=no ]) +if test "$masterpw" != "no"; then + if test "$masterpw" = "yes"; then + AC_MSG_ERROR([Master password must be specified on the command line.]) + fi + AC_DEFINE_UNQUOTED(BPC_CONF_MASTER_PASSWORD, "$masterpw", [Define to the master password]) +fi + +AC_ARG_WITH(updateurl, AC_HELP_STRING([--with-updateurl], [Enable support for a hard-coded update URL]), [ updateurl="$withval" ], [ updateurl=no ]) +if test "$updateurl" != "no"; then + if test "$updateurl" = "yes"; then + AC_MSG_ERROR([URL must be specified on the command line.]) + fi + AC_DEFINE_UNQUOTED(BPC_CONF_UPDATEURL, "$updateurl", [Define to the URL to update against]) +fi + +AC_ARG_WITH(notifyserv, AC_HELP_STRING([--with-notifyserv], [Enable support for a hard-coded notification server]), [ notifyserv="$withval" ], [ notifyserv=no ]) +if test "$notifyserv" != "no"; then + if test "$notifyserv" = "yes"; then + AC_MSG_ERROR([Notification server must be specified on the command line.]) + fi + AC_DEFINE_UNQUOTED(BPC_CONF_NOTIFYSERV, "$notifyserv", [Define to the server to send host notifications to]) +fi + +AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug], [Enable debugging support.]), [ debugenabled=$enableval ], [ debugenabled=no ]) +if test "$debugenabled" = "no"; then + AC_DEFINE(NDEBUG, [1], [Define if you wish to disable debugging support]) +else + AC_DEFINE(DEBUG, [1], [Define if you wish to enable debugging support]) +fi + +AC_C_BIGENDIAN(,, [ + AC_DEFINE(ENDIAN_UNKNOWN, [1], [Define this to 1 if you do not know what endian-ness your platform is.]) +]) + +AC_ARG_ENABLE(static, AC_HELP_STRING([--enable-static], [Enable (mostly) static build.]), [ staticbuild=$enableval ], [ staticbuild=no ]) +if test ! "$staticbuild" = "no"; then + DC_MAKE_STATIC +fi + + +AC_OUTPUT(Makefile) diff --git a/doc/attrib.txt b/doc/attrib.txt new file mode 100644 index 0000000..2a13a85 --- /dev/null +++ b/doc/attrib.txt @@ -0,0 +1,21 @@ +[MAGIC_NUMBER (32 bits): == 0x17555556] + { + [FILE_NAME_LEN (32 bits)] + [PATH_NAME_LEN (32 bits)] + [FILE_NAME (FILE_NAME_LEN * 8 bits)] + [PATH_NAME (PATH_NAME_LEN * bits)] + [FILE_TYPE (16 bits)] + [FILE_MODE (32 bits)] + [FILE_MTIME (32 bits)] + [FILE_SIZE_LOWER (32 bits)] + [FILE_SIZE_UPPER (32 bits)] + [FILE_ATTRS_LEN (32 bits)] + FILE_ATTRS { + [ATTR_ID (16 bits)] + [ATTR_LEN (32 bits)] + [ATTR_VAL (ATTR_LEN * 8 bits)] + } (FILE_ATTRS_LEN * 8 bits) + } + +Where "FILE_NAME" is the remote file name and "PATH_NAME" is mangled, locally +stored path name. diff --git a/doc/backuppcd.pdf b/doc/backuppcd.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f57bd5ffd4582a95ae101ebe6f888d43a28e869e GIT binary patch literal 123464 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 +#endif + +/* Enable GNU extensions in fnmatch.h. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif + +#include +#include +#include + +#if HAVE_STRING_H || defined _LIBC +# include +#else +# include +#endif + +#if defined STDC_HEADERS || defined _LIBC +# include +#endif + +/* For platform which support the ISO C amendement 1 functionality we + support user defined character classes. */ +#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) +/* Solaris 2.5 has a bug: must be included before . */ +# include +# include +#endif + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#if defined _LIBC || !defined __GNU_LIBRARY__ + + +# if defined STDC_HEADERS || !defined isascii +# define ISASCII(c) 1 +# else +# define ISASCII(c) isascii(c) +# endif + +# ifdef isblank +# define ISBLANK(c) (ISASCII (c) && isblank (c)) +# else +# define ISBLANK(c) ((c) == ' ' || (c) == '\t') +# endif +# ifdef isgraph +# define ISGRAPH(c) (ISASCII (c) && isgraph (c)) +# else +# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c)) +# endif + +# define ISPRINT(c) (ISASCII (c) && isprint (c)) +# define ISDIGIT(c) (ISASCII (c) && isdigit (c)) +# define ISALNUM(c) (ISASCII (c) && isalnum (c)) +# define ISALPHA(c) (ISASCII (c) && isalpha (c)) +# define ISCNTRL(c) (ISASCII (c) && iscntrl (c)) +# define ISLOWER(c) (ISASCII (c) && islower (c)) +# define ISPUNCT(c) (ISASCII (c) && ispunct (c)) +# define ISSPACE(c) (ISASCII (c) && isspace (c)) +# define ISUPPER(c) (ISASCII (c) && isupper (c)) +# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c)) + +# define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) + +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) +/* The GNU C library provides support for user-defined character classes + and the functions from ISO C amendement 1. */ +# ifdef CHARCLASS_NAME_MAX +# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX +# else +/* This shouldn't happen but some implementation might still have this + problem. Use a reasonable default value. */ +# define CHAR_CLASS_MAX_LENGTH 256 +# endif + +# ifdef _LIBC +# define IS_CHAR_CLASS(string) __wctype (string) +# else +# define IS_CHAR_CLASS(string) wctype (string) +# endif +# else +# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ + +# define IS_CHAR_CLASS(string) \ + (STREQ (string, "alpha") || STREQ (string, "upper") \ + || STREQ (string, "lower") || STREQ (string, "digit") \ + || STREQ (string, "alnum") || STREQ (string, "xdigit") \ + || STREQ (string, "space") || STREQ (string, "print") \ + || STREQ (string, "punct") || STREQ (string, "graph") \ + || STREQ (string, "cntrl") || STREQ (string, "blank")) +# endif + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +# if !defined _LIBC && !defined getenv +extern char *getenv (); +# endif + +# ifndef errno +extern int errno; +# endif + +/* This function doesn't exist on most systems. */ + +# if !defined HAVE___STRCHRNUL && !defined _LIBC +static char * +__strchrnul (s, c) + const char *s; + int c; +{ + char *result = strchr (s, c); + if (result == NULL) + result = strchr (s, '\0'); + return result; +} +# endif + +# ifndef internal_function +/* Inside GNU libc we mark some function in a special way. In other + environments simply ignore the marking. */ +# define internal_function +# endif + +/* Match STRING against the filename pattern PATTERN, returning zero if + it matches, nonzero if not. */ +static int internal_fnmatch __P ((const char *pattern, const char *string, + int no_leading_period, int flags)) + internal_function; +static int +internal_function +internal_fnmatch (pattern, string, no_leading_period, flags) + const char *pattern; + const char *string; + int no_leading_period; + int flags; +{ + register const char *p = pattern, *n = string; + register unsigned char c; + +/* Note that this evaluates C many times. */ +# ifdef _LIBC +# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c)) +# else +# define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c)) +# endif + + while ((c = *p++) != '\0') + { + c = FOLD (c); + + switch (c) + { + case '?': + if (*n == '\0') + return FNM_NOMATCH; + else if (*n == '/' && (flags & FNM_FILE_NAME)) + return FNM_NOMATCH; + else if (*n == '.' && no_leading_period + && (n == string + || (n[-1] == '/' && (flags & FNM_FILE_NAME)))) + return FNM_NOMATCH; + break; + + case '\\': + if (!(flags & FNM_NOESCAPE)) + { + c = *p++; + if (c == '\0') + /* Trailing \ loses. */ + return FNM_NOMATCH; + c = FOLD (c); + } + if (FOLD ((unsigned char) *n) != c) + return FNM_NOMATCH; + break; + + case '*': + if (*n == '.' && no_leading_period + && (n == string + || (n[-1] == '/' && (flags & FNM_FILE_NAME)))) + return FNM_NOMATCH; + + for (c = *p++; c == '?' || c == '*'; c = *p++) + { + if (*n == '/' && (flags & FNM_FILE_NAME)) + /* A slash does not match a wildcard under FNM_FILE_NAME. */ + return FNM_NOMATCH; + else if (c == '?') + { + /* A ? needs to match one character. */ + if (*n == '\0') + /* There isn't another character; no match. */ + return FNM_NOMATCH; + else + /* One character of the string is consumed in matching + this ? wildcard, so *??? won't match if there are + less than three characters. */ + ++n; + } + } + + if (c == '\0') + /* The wildcard(s) is/are the last element of the pattern. + If the name is a file name and contains another slash + this does mean it cannot match. */ + return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL + ? FNM_NOMATCH : 0); + else + { + const char *endp; + + endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0'); + + if (c == '[') + { + int flags2 = ((flags & FNM_FILE_NAME) + ? flags : (flags & ~FNM_PERIOD)); + + for (--p; n < endp; ++n) + if (internal_fnmatch (p, n, + (no_leading_period + && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))), + flags2) + == 0) + return 0; + } + else if (c == '/' && (flags & FNM_FILE_NAME)) + { + while (*n != '\0' && *n != '/') + ++n; + if (*n == '/' + && (internal_fnmatch (p, n + 1, flags & FNM_PERIOD, + flags) == 0)) + return 0; + } + else + { + int flags2 = ((flags & FNM_FILE_NAME) + ? flags : (flags & ~FNM_PERIOD)); + + if (c == '\\' && !(flags & FNM_NOESCAPE)) + c = *p; + c = FOLD (c); + for (--p; n < endp; ++n) + if (FOLD ((unsigned char) *n) == c + && (internal_fnmatch (p, n, + (no_leading_period + && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))), + flags2) == 0)) + return 0; + } + } + + /* If we come here no match is possible with the wildcard. */ + return FNM_NOMATCH; + + case '[': + { + /* Nonzero if the sense of the character class is inverted. */ + static int posixly_correct; + register int not; + char cold; + + if (posixly_correct == 0) + posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1; + + if (*n == '\0') + return FNM_NOMATCH; + + if (*n == '.' && no_leading_period && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))) + return FNM_NOMATCH; + + if (*n == '/' && (flags & FNM_FILE_NAME)) + /* `/' cannot be matched. */ + return FNM_NOMATCH; + + not = (*p == '!' || (posixly_correct < 0 && *p == '^')); + if (not) + ++p; + + c = *p++; + for (;;) + { + unsigned char fn = FOLD ((unsigned char) *n); + + if (!(flags & FNM_NOESCAPE) && c == '\\') + { + if (*p == '\0') + return FNM_NOMATCH; + c = FOLD ((unsigned char) *p); + ++p; + + if (c == fn) + goto matched; + } + else if (c == '[' && *p == ':') + { + /* Leave room for the null. */ + char str[CHAR_CLASS_MAX_LENGTH + 1]; + size_t c1 = 0; +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) + wctype_t wt; +# endif + const char *startp = p; + + for (;;) + { + if (c1 == CHAR_CLASS_MAX_LENGTH) + /* The name is too long and therefore the pattern + is ill-formed. */ + return FNM_NOMATCH; + + c = *++p; + if (c == ':' && p[1] == ']') + { + p += 2; + break; + } + if (c < 'a' || c >= 'z') + { + /* This cannot possibly be a character class name. + Match it as a normal range. */ + p = startp; + c = '['; + goto normal_bracket; + } + str[c1++] = c; + } + str[c1] = '\0'; + +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) + wt = IS_CHAR_CLASS (str); + if (wt == 0) + /* Invalid character class name. */ + return FNM_NOMATCH; + + if (__iswctype (__btowc ((unsigned char) *n), wt)) + goto matched; +# else + if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n)) + || (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n)) + || (STREQ (str, "blank") && ISBLANK ((unsigned char) *n)) + || (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n)) + || (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n)) + || (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n)) + || (STREQ (str, "lower") && ISLOWER ((unsigned char) *n)) + || (STREQ (str, "print") && ISPRINT ((unsigned char) *n)) + || (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n)) + || (STREQ (str, "space") && ISSPACE ((unsigned char) *n)) + || (STREQ (str, "upper") && ISUPPER ((unsigned char) *n)) + || (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n))) + goto matched; +# endif + } + else if (c == '\0') + /* [ (unterminated) loses. */ + return FNM_NOMATCH; + else + { + normal_bracket: + if (FOLD (c) == fn) + goto matched; + + cold = c; + c = *p++; + + if (c == '-' && *p != ']') + { + /* It is a range. */ + unsigned char cend = *p++; + if (!(flags & FNM_NOESCAPE) && cend == '\\') + cend = *p++; + if (cend == '\0') + return FNM_NOMATCH; + + if (cold <= fn && fn <= FOLD (cend)) + goto matched; + + c = *p++; + } + } + + if (c == ']') + break; + } + + if (!not) + return FNM_NOMATCH; + break; + + matched: + /* Skip the rest of the [...] that already matched. */ + while (c != ']') + { + if (c == '\0') + /* [... (unterminated) loses. */ + return FNM_NOMATCH; + + c = *p++; + if (!(flags & FNM_NOESCAPE) && c == '\\') + { + if (*p == '\0') + return FNM_NOMATCH; + /* XXX 1003.2d11 is unclear if this is right. */ + ++p; + } + else if (c == '[' && *p == ':') + { + do + if (*++p == '\0') + return FNM_NOMATCH; + while (*p != ':' || p[1] == ']'); + p += 2; + c = *p; + } + } + if (not) + return FNM_NOMATCH; + } + break; + + default: + if (c != FOLD ((unsigned char) *n)) + return FNM_NOMATCH; + } + + ++n; + } + + if (*n == '\0') + return 0; + + if ((flags & FNM_LEADING_DIR) && *n == '/') + /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ + return 0; + + return FNM_NOMATCH; + +# undef FOLD +} + + +int +fnmatch (pattern, string, flags) + const char *pattern; + const char *string; + int flags; +{ + return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags); +} + +#endif /* _LIBC or not __GNU_LIBRARY__. */ diff --git a/fnmatch.h b/fnmatch.h new file mode 100644 index 0000000..cc3ec37 --- /dev/null +++ b/fnmatch.h @@ -0,0 +1,84 @@ +/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C 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. + + The GNU C 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 the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _FNMATCH_H +#define _FNMATCH_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32 +# if !defined __GLIBC__ || !defined __P +# undef __P +# define __P(protos) protos +# endif +#else /* Not C++ or ANSI C. */ +# undef __P +# define __P(protos) () +/* We can get away without defining `const' here only because in this file + it is used only inside the prototype for `fnmatch', which is elided in + non-ANSI C where `const' is problematical. */ +#endif /* C++ or ANSI C. */ + +#ifndef const +# if (defined __STDC__ && __STDC__) || defined __cplusplus +# define __const const +# else +# define __const +# endif +#endif + +/* We #undef these before defining them because some losing systems + (HP-UX A.08.07 for example) define these in . */ +#undef FNM_PATHNAME +#undef FNM_NOESCAPE +#undef FNM_PERIOD + +/* Bits set in the FLAGS argument to `fnmatch'. */ +#define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */ +#define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */ +#define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */ + +#if !defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _GNU_SOURCE +# define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */ +# define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */ +# define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */ +#endif + +/* Value returned by `fnmatch' if STRING does not match PATTERN. */ +#define FNM_NOMATCH 1 + +/* This value is returned if the implementation does not support + `fnmatch'. Since this is not the case here it will never be + returned but the conformance test suites still require the symbol + to be defined. */ +#ifdef _XOPEN_SOURCE +# define FNM_NOSYS (-1) +#endif + +/* Match NAME against the filename pattern PATTERN, + returning zero if it matches, FNM_NOMATCH if not. */ +extern int fnmatch __P ((__const char *__pattern, __const char *__name, + int __flags)); + +#ifdef __cplusplus +} +#endif + +#endif /* fnmatch.h */ diff --git a/gethostname.c b/gethostname.c new file mode 100644 index 0000000..6365b78 --- /dev/null +++ b/gethostname.c @@ -0,0 +1,32 @@ +#include "compat.h" + +/* + * We may be compiled even if a gethostname() function exists, therefore + * if we detect that it does exist we should not do anything. + */ +#ifndef HAVE_GETHOSTNAME + +#include "gethostname.h" + +int gethostname(char *name, size_t len) { + int retval = -1; +#ifdef _USE_WIN32_ + BOOL gcn_ret; + char *tmpname; + + tmpname = malloc(len); + + gcn_ret = GetComputerName(tmpname, &len); + if (gcn_ret) { + memcpy(name, tmpname, len); + name[len] = '\0'; + + retval = 0; + } + + free(tmpname); +#endif + return(retval); +} + +#endif diff --git a/gethostname.h b/gethostname.h new file mode 100644 index 0000000..facb729 --- /dev/null +++ b/gethostname.h @@ -0,0 +1,18 @@ +#ifndef _REPL_GETHOSTBYNAME_H +#define _REPL_GETHOSTBYNAME_H + +#include "compat.h" + +#ifndef HOST_NAME_MAX +# ifdef _USE_WIN32_ +# ifdef MAX_COMPUTERNAME_LENGTH +# define HOST_NAME_MAX MAX_COMPUTERNAME_LENGTH +# endif +# else +# define HOST_NAME_MAX 255 +# endif +#endif + +int gethostname(char *name, size_t len); + +#endif diff --git a/htonll.c b/htonll.c new file mode 100644 index 0000000..8a2f12e --- /dev/null +++ b/htonll.c @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#include "compat.h" + +#ifndef HAVE_HTONLL + +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_ENDIAN_H +#include +#endif + +#ifndef __BIG_ENDIAN +#define __BIG_ENDIAN 4321 +#endif +#ifndef __LITTLE_ENDIAN +#define __LITTLE_ENDIAN 1234 +#endif + +#ifndef __BYTE_ORDER +#ifdef WORDS_BIGENDIAN +#define __BYTE_ORDER __BIG_ENDIAN +#else +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#endif + +#include "htonll.h" + +uint64_t htonll(uint64_t n) { + uint64_t retval; + +#if __BYTE_ORDER == __BIG_ENDIAN + retval = n; +#else + retval = ((uint64_t) htonl(n & 0xFFFFFFFFLLU)) << 32; + retval |= htonl((n & 0xFFFFFFFF00000000LLU) >> 32); +#endif + return(retval); +} + +#endif diff --git a/htonll.h b/htonll.h new file mode 100644 index 0000000..b70652d --- /dev/null +++ b/htonll.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#ifndef _RSK_HTONLL_H +#define _RSK_HTONLL_H + +#include "compat.h" + +#ifndef HAVE_HTONLL + +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_ENDIAN_H +#include +#endif + +uint64_t htonll(uint64_t n); + +#endif +#endif diff --git a/install-sh b/install-sh new file mode 100755 index 0000000..e9de238 --- /dev/null +++ b/install-sh @@ -0,0 +1,251 @@ +#!/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 + true +fi + +if [ x"$dir_arg" != x ]; then + dst=$src + src="" + + if [ -d $dst ]; then + instcmd=: + chmodcmd="" + else + instcmd=mkdir + 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 + true + else + echo "install: $src does not exist" + exit 1 + fi + + if [ x"$dst" = x ] + then + echo "install: no destination specified" + exit 1 + else + true + 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 + true + 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 + true + fi + + pathcomp="${pathcomp}/" +done +fi + +if [ x"$dir_arg" != x ] +then + $doit $instcmd $dst && + + if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi && + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi && + if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi && + if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; 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 + true + 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 true;fi && + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi && + if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi && + if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi && + +# Now rename the file to the real destination. + + $doit $rmcmd -f $dstdir/$dstfile && + $doit $mvcmd $dsttmp $dstdir/$dstfile + +fi && + + +exit 0 diff --git a/libbackuppc.c b/libbackuppc.c new file mode 100644 index 0000000..e69de29 diff --git a/libbackuppc.h b/libbackuppc.h new file mode 100644 index 0000000..e69de29 diff --git a/libbackuppcd.c b/libbackuppcd.c new file mode 100644 index 0000000..c123fcc --- /dev/null +++ b/libbackuppcd.c @@ -0,0 +1,1784 @@ +#include "compat.h" +#include "backuppcd.h" +#include "backuppcd-common.h" +#include "libbackuppcd.h" +#include "sha1.h" +#include "net.h" + +#define BPC_CMD_GET_DATA (BPC_CMD_GET | 0x100) +#define BPC_MAX_RDIFF_BLOCKSIZE 8192 + +/* + * This structure contains all the variables that are needed to keep track of + * the state of a transfer (GET). + */ +struct bpc_transfer { + uint64_t filesize; + int64_t idealblocknum; + uint32_t currblocknum; + uint32_t blocksize; + uint32_t blockoffset; +}; + +/* + * This structure is used as a handle for a connection to a BackupPC server. + */ +struct bpc_conn { + struct bpc_fileinfo dent; + struct bpc_transfer tinfo; + backuppc_cmd_t state; + int fd; +}; + +/* + * These values are used by _bpc_client_read() and _bpc_client_write() to + * determine the type of variable to read or write. + */ +typedef enum { + BPC_CDT_END, + BPC_CDT_UINT8, + BPC_CDT_UINT16, + BPC_CDT_UINT32, + BPC_CDT_UINT64, + BPC_CDT_BYTEARRAY, + BPC_CDT_STRING, + BPC_CDT_STRING_PTR, + BPC_CDT_SINK, +} bpc_clntdt_t; + +#ifndef MSG_WAITALL +#define MSG_WAITALL 0 +#endif + +#ifndef BPC_MAXPATH_LEN +#define BPC_MAXPATH_LEN 4096 +#endif + +/* + * SYNOPSIS (internal): + * static int _bpc_client_read( + * const int sockid, + * ... + * ); + * + * ARGUMENTS: + * const int sockid Socket descriptor to read from + * ... List of parameters with the appropriate type + * and terminated by a BPC_CDT_END + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function reads a variable number of parameters in various formats + * from a socket descriptor and stores them in the pointer given. To + * specify a value, use the appropriate value from `bpc_clntdt_t' followed + * by a pointer to the memory location to store the actual value (in most + * cases) or the size of the memory location and the start of the memory + * location (for BYTEARRAY, STRING, STRING_PTR). + * + * If the pointer at the pointed to location is NULL and the data type is + * STRING_PTR (size) bytes will be allocated and (size-1) bytes read. + * You are responsible for deallocating allocated memory using free(). + * + * This is an internal function and not part of the LibBackupPCd API and + * therefore subject to change or removal. + * + * EXAMPLES: + * uint8_t val_u8; + * char *val_str = NULL; + * + * // Read a uint8_t into val_u8 + * if (!_bpc_client_read(sockid, BPC_CDT_UINT8, &val_u8, BPC_CDT_END)) { + * return(-1); + * } + * + * // Read 4 bytes and a NIL termination char into newly allocated memory + * if (!_bpc_client_read(sockid, BPC_CDT_STRING_PTR, (size_t) 5, &val_str, BPC_CDT_END)) { + * return(-1); + * } + * + * if (val_str) { + * free(val_str); + * } + * + */ +static int _bpc_client_read(const int sockid, ...) { + bpc_clntdt_t typeid; + char tmpbuf[1024]; + va_list ap; + uint8_t *u8v; + uint16_t *u16v; + uint32_t *u32v; + uint64_t *u64v; + char *cpv, **cppv; + void *vpv = NULL, *vpv_s; + size_t vpv_len, bytes_to_copy; + ssize_t read_ret; + + va_start(ap, sockid); + while (1) { + typeid = va_arg(ap, bpc_clntdt_t); + + if (typeid == BPC_CDT_END) { + break; + } + + switch (typeid) { + case BPC_CDT_UINT8: + u8v = va_arg(ap, uint8_t *); + vpv_len = sizeof(*u8v); + vpv = u8v; + break; + case BPC_CDT_UINT16: + u16v = va_arg(ap, uint16_t *); + vpv_len = sizeof(*u16v); + vpv = u16v; + break; + case BPC_CDT_UINT32: + u32v = va_arg(ap, uint32_t *); + vpv_len = sizeof(*u32v); + vpv = u32v; + break; + case BPC_CDT_UINT64: + u64v = va_arg(ap, uint64_t *); + vpv_len = sizeof(*u64v); + vpv = u64v; + break; + case BPC_CDT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_CDT_STRING: + vpv_len = va_arg(ap, size_t); + vpv_len--; + cpv = va_arg(ap, char *); + cpv[vpv_len] = '\0'; + vpv = cpv; + break; + case BPC_CDT_STRING_PTR: + vpv_len = va_arg(ap, size_t); + cppv = va_arg(ap, char **); + if (*cppv == NULL) { + cpv = *cppv = malloc(vpv_len + 1); + cpv[vpv_len] = '\0'; + } else { + cpv = *cppv; + } + vpv = cpv; + break; + case BPC_CDT_SINK: + vpv_len = va_arg(ap, size_t); + vpv = NULL; + break; + case BPC_CDT_END: + return(0); + break; + default: + return(0); + } + + vpv_s = vpv; + while (vpv_len) { + if (vpv) { + read_ret = recv(sockid, vpv, vpv_len, MSG_WAITALL); + } else { + /* + * If we have been given no place to put the + * data, we just read it to a buffer and + * ignore it (aka, sink it). + */ + bytes_to_copy = sizeof(tmpbuf); + if (vpv_len < bytes_to_copy) { + bytes_to_copy = vpv_len; + } + read_ret = recv(sockid, tmpbuf, bytes_to_copy, MSG_WAITALL); + } + + if (read_ret <= 0) { + return(0); + } + + vpv_len -= read_ret; + + if (vpv) { + vpv += read_ret; + } + } + vpv = vpv_s; + + switch (typeid) { + case BPC_CDT_UINT16: + u16v = vpv; + *u16v = ntohs(*u16v); + break; + case BPC_CDT_UINT32: + u32v = vpv; + *u32v = ntohl(*u32v); + break; + case BPC_CDT_UINT64: + u64v = vpv; + *u64v = ntohll(*u64v); + break; + default: + break; + } + } + va_end(ap); + + return(1); +} + +/* + * SYNOPSIS (internal): + * static int _bpc_client_write( + * const int sockid, + * ... + * ); + * + * ARGUMENTS: + * const int sockid Socket descriptor to write to + * ... List of parameters with the appropriate type + * and terminated by a BPC_CDT_END + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function writes a variable number of parameters in various formats + * to a socket descriptor. To specify a value, use the appropriate value + * from `bpc_clntdt_t' followed by a value of the appropriate type (in most + * cases), or the size of the data to write followed by the appropriate + * value (for BYTEARRAY, STRING, STRING_PTR) + * + * This is an internal function and not part of the LibBackupPCd API and + * therefore subject to change or removal. + * + * EXAMPLES: + * uint8_t val_u8 = 3; + * char *val_str = "Joe"; + * + * // Write 3 in a uint8_t format to the socket + * if (!_bpc_client_write(sockid, BPC_CDT_UINT8, val_u8, BPC_CDT_END)) { + * return(-1); + * } + * + * // Write 3 bytes from a string to the socket + * if (!_bpc_client_write(sockid, BPC_CDT_STRING, (size_t) 3, val_str, BPC_CDT_END)) { + * return(-1); + * } + * + */ +static int _bpc_client_write(const int sockid, ...) { + bpc_clntdt_t typeid; + va_list ap; + uint8_t u8v; + uint16_t u16v; + uint32_t u32v; + uint64_t u64v; + void *vpv; + char *cpv; + size_t vpv_len; + ssize_t write_ret; + + va_start(ap, sockid); + while (1) { + typeid = va_arg(ap, bpc_clntdt_t); + + if (typeid == BPC_CDT_END) { + break; + } + + switch (typeid) { + case BPC_CDT_UINT8: + u8v = va_arg(ap, int); + vpv_len = sizeof(u8v); + vpv = &u8v; + break; + case BPC_CDT_UINT16: + u16v = va_arg(ap, int); + u16v = htons(u16v); + vpv_len = sizeof(u16v); + vpv = &u16v; + break; + case BPC_CDT_UINT32: + u32v = va_arg(ap, uint32_t); + u32v = htonl(u32v); + vpv_len = sizeof(u32v); + vpv = &u32v; + break; + case BPC_CDT_UINT64: + u64v = va_arg(ap, uint64_t); + u64v = htonll(u64v); + vpv_len = sizeof(u64v); + vpv = &u64v; + break; + case BPC_CDT_BYTEARRAY: + vpv_len = va_arg(ap, size_t); + vpv = va_arg(ap, void *); + break; + case BPC_CDT_STRING: + cpv = va_arg(ap, char *); + vpv_len = strlen(cpv); + vpv = cpv; + break; + case BPC_CDT_SINK: + case BPC_CDT_STRING_PTR: + case BPC_CDT_END: + return(0); + default: + return(0); + } + + while (vpv_len) { + write_ret = send(sockid, vpv, vpv_len, 0); + + if (write_ret < 0) { + return(0); + } + + vpv_len -= write_ret; + vpv += write_ret; + } + } + va_end(ap); + + return(1); +} + +/* + * SYNOPSIS: + * int bpc_auth( + * BPC_CONN *handle, + * const char *username, + * const char *password + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * const char *username Username to authenticate with + * const char *password Password to authenticate with + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function authenticates with the server specified by the handle. + * + * EXAMPLES: + * + * // Authenticate with the user "user" and password "pass" + * if (!bpc_auth(bpc_handle, "user", "pass")) { + * return(-1); + * } + */ +int bpc_auth(BPC_CONN *handle, const char *username, const char *password) { + uint8_t cmd_reply; + uint8_t status; + int sockid; + + if (!handle || !username || !password) { + CHECKPOINT; + return(0); + } + + if (handle->state != BPC_CMD_NONE) { + CHECKPOINT; + return(0); + } + + sockid = handle->fd; + + if (!_bpc_client_write(sockid, + BPC_CDT_UINT8, (uint8_t) BPC_CMD_AUTH, + BPC_CDT_UINT16, (uint16_t) strlen(username), + BPC_CDT_UINT16, (uint16_t) strlen(password), + BPC_CDT_STRING, username, + BPC_CDT_STRING, password, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &cmd_reply, + BPC_CDT_UINT8, (uint8_t *) &status, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (cmd_reply != BPC_CMD_AUTH_REPLY) { + CHECKPOINT; + return(0); + } + + if (status != BPC_STATUS_OKAY) { + CHECKPOINT; + return(0); + } + + CHECKPOINT; + return(1); +} + +/* + * SYNOPSIS (internal): + * static int _bpc_listget_open( + * BPC_CONN *handle, + * backuppc_cmd_t sendcmd, + * const char *rootpath, + * const int recursive, + * backuppc_hashid_t hashalgo, + * const char *exclpat, + * const char *inclpat + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * backuppc_cmd_t sendcmd Command to send (BPC_CMD_LIST or BPC_CMD_GET) + * const char *rootpath Root path to start the GET or LIST from + * const int recursive Boolean option to specify whether or not to + * recurse into directories + * backuppc_hashid_t hashalgo OR'd list of hash algorithms to ask the + * server to compute for each file + * const char *exclpat <> + * const char *inclpat <> + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function initiates a LIST or GET command (depending on the value of + * the `sendcmd' parameter) and updates the internal state to indicate that + * it is in the middle of such a command. + * + * You should then call _bpc_list() to get either the LIST results or the + * header of a GET result. + * + * This is an internal function and not part of the LibBackupPCd API and + * therefore subject to change or removal. + * + * EXAMPLES: + * + * // List every node under the root directory non-recursively with no + * // hashing performed on files. + * if (!_bpc_listget_open(bpc_handle, BPC_CMD_LIST, "/", 0, BPC_HASH_NONE, NULL, NULL)) { + * return(-1); + * } + * + */ +static int _bpc_listget_open(BPC_CONN *handle, backuppc_cmd_t sendcmd, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat) { + uint8_t cmd, cmd_options = 0; + int sockid; + + sockid = handle->fd; + + if (sendcmd != BPC_CMD_LIST && sendcmd != BPC_CMD_GET) { + CHECKPOINT; + return(0); + } + + /* + * Handle NULL patterns as blank ones. + */ + if (!exclpat) { + exclpat = ""; + } + if (!inclpat) { + inclpat = ""; + } + + if (recursive) { + cmd_options |= BPC_OPT_RECURSIVE; + } + + switch (hashalgo) { + case BPC_HASH_NONE: + break; + case BPC_HASH_MD4: + cmd_options |= BPC_OPT_MD4; + break; + case BPC_HASH_MD5: + cmd_options |= BPC_OPT_MD5; + break; + case BPC_HASH_SHA1: + cmd_options |= BPC_OPT_SHA1; + break; + case BPC_HASH_BPC: + cmd_options |= BPC_OPT_BPCHASH; + break; + } + + if (!_bpc_client_write(sockid, + BPC_CDT_UINT8, (uint8_t) sendcmd, + BPC_CDT_UINT8, (uint8_t) cmd_options, + BPC_CDT_UINT32, (uint32_t) strlen(exclpat), + BPC_CDT_UINT32, (uint32_t) strlen(inclpat), + BPC_CDT_UINT32, (uint32_t) strlen(rootpath), + BPC_CDT_STRING, (char *) rootpath, + BPC_CDT_STRING, (char *) exclpat, + BPC_CDT_STRING, (char *) inclpat, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &cmd, + BPC_CDT_END)) { + CHECKPOINT; + return(0); + } + + /* + * If the server sends us a reply for something other than what we + * asked for, something went wrong, abort. + */ + if (cmd != (sendcmd | 0x80)) { + CHECKPOINT; + return(0); + } + + handle->state = sendcmd; + + handle->dent.owner_group[0] = '\0'; + handle->dent.owner_user[0] = '\0'; + handle->dent.linkdest[0] = '\0'; + handle->dent.name[0] = '\0'; + + memset(&handle->dent.hash_md4, 0, sizeof(handle->dent.hash_md4)); + memset(&handle->dent.hash_md5, 0, sizeof(handle->dent.hash_md5)); + memset(&handle->dent.hash_sha1, 0, sizeof(handle->dent.hash_sha1)); + memset(&handle->dent.hash_bpc, 0, sizeof(handle->dent.hash_bpc)); + + CHECKPOINT; + return(1); +} + +/* + * SYNOPSIS (internal): + * static int _bpc_listget_close( + * BPC_CONN *handle + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function sets the state of a handle back to NONE after a LIST or GET + * request has finished. + * + * This is an internal function and not part of the LibBackupPCd API and + * therefore subject to change or removal. + * + * EXAMPLES: + * + * // Terminate an existing LIST or GET command + * if (!_bpc_listget_close(bpc_handle)) { + * return(-1); + * } + * + */ +static int _bpc_listget_close(BPC_CONN *handle) { + + handle->state = BPC_CMD_NONE; + + CHECKPOINT; + return(1); +} + +/* + * SYNOPSIS (internal): + * static struct bpc_fileinfo *_bpc_list( + * BPC_CONN *handle, + * backuppc_cmd_t cmd + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * backuppc_cmd_t cmd Command to process results from (LIST or GET) + * + * RETURN VALUE: + * This function returns a pointer to a (struct bpc_fileinfo) object. The + * contents of this objects may be overwritten with subsequent calls to + * _bpc_list() for the same handle. NULL is returned on error or when no + * more objects exist in the stream. + * + * NOTES: + * This function gets the contents of a LIST_REPLY or GET_REPLY from the + * handle and sets them in the (struct bpc_fileinfo) value that it + * returns. If it is processing a GET_REPLY it also initializes the + * values in the (struct bpc_transfer) members. + * + * This is an internal function and not part of the LibBackupPCd API and + * therefore subject to change or removal. + * + * EXAMPLES: + * + * // Get an item from an open LIST command + * struct bpc_fileinfo *fileinfo; + * + * fileinfo = _bpc_list(bpc_handle, BPC_CMD_LIST); + * + * if (!fileinfo) { + * return(-1); + * } + * + */ +static struct bpc_fileinfo *_bpc_list(BPC_CONN *handle, backuppc_cmd_t cmd) { + struct bpc_fileinfo *ret; + struct bpc_transfer *tinfo; + int sockid; + + uint64_t filesize; + uint32_t attr_sect_len, blocksize, pathnamelen; + uint32_t attr_uid, attr_gid, attr_ctime, attr_mtime, attr_devmajor, attr_devminor; + uint32_t attrlen; + uint16_t attrid; + uint16_t attr_mode; + uint8_t filetype; + mode_t modeval; + + ret = &handle->dent; + tinfo = &handle->tinfo; + + sockid = handle->fd; + + if (!_bpc_client_read(sockid, + BPC_CDT_UINT8, (uint8_t *) &filetype, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + if (filetype == 0xff) { + _bpc_listget_close(handle); + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_sect_len, + BPC_CDT_UINT64, (uint64_t *) &filesize, + BPC_CDT_UINT32, (uint32_t *) &blocksize, + BPC_CDT_UINT32, (uint32_t *) &pathnamelen, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + if (pathnamelen >= sizeof(ret->name)) { + SPOTVAR_I(pathnamelen); + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_STRING, (size_t) (pathnamelen + 1), &ret->name, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + attr_uid = 0; + attr_gid = 0; + attr_mode = 0; + attr_ctime = 0; + attr_mtime = 0; + attr_devmajor = 0; + attr_devminor = 0; + + memset(ret->hash_md4, '\0', sizeof(ret->hash_md4)); + memset(ret->hash_md5, '\0', sizeof(ret->hash_md5)); + memset(ret->hash_bpc, '\0', sizeof(ret->hash_bpc)); + memset(ret->hash_sha1, '\0', sizeof(ret->hash_sha1)); + + /* + * Read the sent attributes. + */ + if (attr_sect_len != 0) { + while (1) { + if (!_bpc_client_read(sockid, + BPC_CDT_UINT16, (uint16_t *) &attrid, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + if (attrid == 0xffff) { + break; + } + + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attrlen, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + switch ((backuppc_attrid_t) attrid) { + case BPC_ATTRID_NOP: + if (attrlen != 0) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_MTIME: + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_mtime, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_CTIME: + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_ctime, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_UID: + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_uid, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_GID: + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, (uint32_t *) &attr_gid, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_ACL: + if (!_bpc_client_read(sockid, + BPC_CDT_UINT16, (uint16_t *) &attr_mode, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + break; + case BPC_ATTRID_USER: + if (attrlen >= sizeof(ret->owner_user)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_STRING, (size_t) attrlen + 1, (char *) &ret->owner_user, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_GROUP: + if (attrlen >= sizeof(ret->owner_group)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_STRING, (size_t) attrlen + 1, (char *) &ret->owner_group, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_SYMLINKDEST: + if (attrlen >= sizeof(ret->linkdest)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_STRING, (size_t) attrlen + 1, (char *) &ret->linkdest, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_HRDLINKDEST: + if (attrlen >= sizeof(ret->linkdest)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_STRING, (size_t) attrlen + 1, (char *) &ret->linkdest, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_MD4: + if (attrlen != sizeof(ret->hash_md4)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_BYTEARRAY, (size_t) sizeof(ret->hash_md4), (void *) &ret->hash_md4, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_MD5: + if (attrlen != sizeof(ret->hash_md5)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_BYTEARRAY, (size_t) sizeof(ret->hash_md5), (void *) &ret->hash_md5, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_SHA1: + if (attrlen != sizeof(ret->hash_sha1)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_BYTEARRAY, (size_t) sizeof(ret->hash_sha1), (void *) &ret->hash_sha1, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; + case BPC_ATTRID_BPCHASH: + if (attrlen != sizeof(ret->hash_bpc)) { + CHECKPOINT; + return(NULL); + } + + if (!_bpc_client_read(sockid, + BPC_CDT_BYTEARRAY, (size_t) sizeof(ret->hash_bpc), (void *) &ret->hash_bpc, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; +#ifndef DEBUG + default: + if (!_bpc_client_read(sockid, + BPC_CDT_SINK, (size_t) attrlen, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + break; +#endif + } + } + } + + /* + * Determine the POSIX "mode" value from the ACL attrs. + */ + modeval = 0; + if (attr_mode) { + if ((attr_mode & BPC_ACL_XUSR) == BPC_ACL_XUSR) { + modeval |= S_IXUSR; + } + if ((attr_mode & BPC_ACL_WUSR) == BPC_ACL_WUSR) { + modeval |= S_IWUSR; + } + if ((attr_mode & BPC_ACL_RUSR) == BPC_ACL_RUSR) { + modeval |= S_IRUSR; + } +#ifndef _USE_WIN32_ + if ((attr_mode & BPC_ACL_XGRP) == BPC_ACL_XGRP) { + modeval |= S_IXGRP; + } + if ((attr_mode & BPC_ACL_WGRP) == BPC_ACL_WGRP) { + modeval |= S_IWGRP; + } + if ((attr_mode & BPC_ACL_RGRP) == BPC_ACL_RGRP) { + modeval |= S_IRGRP; + } + if ((attr_mode & BPC_ACL_XOTH) == BPC_ACL_XOTH) { + modeval |= S_IXOTH; + } + if ((attr_mode & BPC_ACL_WOTH) == BPC_ACL_WOTH) { + modeval |= S_IWOTH; + } + if ((attr_mode & BPC_ACL_ROTH) == BPC_ACL_ROTH) { + modeval |= S_IROTH; + } + if ((attr_mode & BPC_ACL_STCK) == BPC_ACL_STCK) { + modeval |= S_ISVTX; + } + if ((attr_mode & BPC_ACL_SGID) == BPC_ACL_SGID) { + modeval |= S_ISGID; + } + if ((attr_mode & BPC_ACL_SUID) == BPC_ACL_SUID) { + modeval |= S_ISUID; + } +#endif + } + +#if 0 + if (filetype == BPC_FILE_REG) { + modeval |= S_IFREG; + } +#ifndef _USE_WIN32_ + if (filetype == BPC_FILE_SYMLINK) { + modeval |= S_IFLNK; + } + if (filetype == BPC_FILE_SOCKET) { + modeval |= S_IFSOCK; + } +#endif + if (filetype == BPC_FILE_DIR) { + modeval |= S_IFDIR; + } + if (filetype == BPC_FILE_BDEV) { + modeval |= S_IFBLK; + } + if (filetype == BPC_FILE_CDEV) { + modeval |= S_IFCHR; + } + if (filetype == BPC_FILE_FIFO) { + modeval |= S_IFIFO; + } +#endif + + ret->mode = modeval; + ret->type = filetype; + ret->size = filesize; + ret->uid = attr_uid; + ret->gid = attr_gid; + ret->mtime = attr_mtime; + ret->ctime = attr_ctime; + + if (cmd == BPC_CMD_GET) { + tinfo->blocksize = blocksize; + tinfo->idealblocknum = -1; + tinfo->currblocknum = 0; + tinfo->filesize = filesize; + tinfo->blockoffset = 0; + } + + return(ret); +} + +/* + * SYNOPSIS: + * int bpc_list_open( + * BPC_CONN *handle, + * const char *rootpath, + * const int recursive, + * backuppc_hashid_t hashalgo, + * const char *exclpat, + * const char *inclpat + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * const char *rootpath Root path to start the GET or LIST from + * const int recursive Boolean option to specify whether or not to + * recurse into directories + * backuppc_hashid_t hashalgo OR'd list of hash algorithms to ask the + * server to compute for each file + * const char *exclpat <> + * const char *inclpat <> + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function initiates a LIST command (by calling _bpc_listget_open()). + * You must not be in the middle of any other command at the time. + * + * You should then call bpc_list() to get the LIST results. + * + * EXAMPLES: + * + * // List every node under the root directory non-recursively with no + * // hashing performed on files. + * if (!bpc_list_open(bpc_handle, "/", 0, BPC_HASH_NONE, NULL, NULL)) { + * return(-1); + * } + * + */ +int bpc_list_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat) { + if (!handle) { + return(0); + } + + if (handle->state != BPC_CMD_NONE) { + return(0); + } + + return(_bpc_listget_open(handle, BPC_CMD_LIST, rootpath, recursive, hashalgo, exclpat, inclpat)); +} + +/* + * SYNOPSIS: + * int bpc_list_close( + * BPC_CONN *handle + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function verifies that a previous operation completed + * sucessfully and that we are now not in the middle of any command. + * + * EXAMPLES: + * + * // Verify that the previous LIST command is complete + * if (!bpc_list_close(bpc_handle)) { + * return(-1); + * } + * + */ +int bpc_list_close(BPC_CONN *handle) { + if (!handle) { + return(0); + } + + if (handle->state != BPC_CMD_NONE) { + return(0); + } + + return(1); +} + +/* + * SYNOPSIS: + * struct bpc_fileinfo *bpc_list( + * BPC_CONN *handle, + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns a pointer to a (struct bpc_fileinfo) object. The + * contents of this objects may be overwritten with subsequent calls to + * bpc_list() for the same handle. NULL is returned on error or when no + * more objects exist in the stream. + * + * NOTES: + * This function gets the contents of a LIST_REPLY from the handle and sets + * them in the (struct bpc_fileinfo) value that it returns. + * + * EXAMPLES: + * + * // Get an item from an open LIST command + * struct bpc_fileinfo *fileinfo; + * + * fileinfo = bpc_list(bpc_handle); + * + * if (!fileinfo) { + * return(-1); + * } + * + */ +struct bpc_fileinfo *bpc_list(BPC_CONN *handle) { + if (!handle) { + return(NULL); + } + + if (handle->state != BPC_CMD_LIST) { + return(NULL); + } + + return(_bpc_list(handle, BPC_CMD_LIST)); +} + +/* + * SYNOPSIS: + * int bpc_get_open( + * BPC_CONN *handle, + * const char *rootpath, + * const int recursive, + * backuppc_hashid_t hashalgo, + * const char *exclpat, + * const char *inclpat + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * const char *rootpath Root path to start the GET or LIST from + * const int recursive Boolean option to specify whether or not to + * recurse into directories + * backuppc_hashid_t hashalgo OR'd list of hash algorithms to ask the + * server to compute for each file + * const char *exclpat <> + * const char *inclpat <> + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function initiates a GET command and updates the internal state to + * indicate that it is in the middle of such a command. + * + * You should then call bpc_get_head() to get the header of the GET result. + * + * EXAMPLES: + * + * // Get every node under "/" non-recursively and do not perform any + * // hashing on the files. + * if (!bpc_get_open(bpc_handle, "/", 0, BPC_HASH_NONE, NULL, NULL)) { + * return(-1); + * } + * + */ +int bpc_get_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat) { + int retval; + + if (!handle) { + CHECKPOINT; + return(0); + } + + if (handle->state != BPC_CMD_NONE) { + CHECKPOINT; + return(0); + } + + retval = _bpc_listget_open(handle, BPC_CMD_GET, rootpath, recursive, hashalgo, exclpat, inclpat); + + if (retval == 0) { + CHECKPOINT; + return(0); + } + + CHECKPOINT; + return(retval); +} + +/* + * SYNOPSIS: + * int bpc_get_close( + * BPC_CONN *handle + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns 0 on failure, 1 on success. + * + * NOTES: + * This function verifies that a previous operation completed + * sucessfully and that we are now not in the middle of any command. + * + * EXAMPLES: + * + * // Verify that we have terminated a previously existing GET command + * if (!bpc_get_close(bpc_handle)) { + * return(-1); + * } + * + */ +int bpc_get_close(BPC_CONN *handle) { + if (!handle) { + return(0); + } + + if (handle->state != BPC_CMD_NONE) { + return(0); + } + + return(1); +} + +/* + * SYNOPSIS (internal): + * struct bpc_fileinfo *bpc_get_head( + * BPC_CONN *handle, + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns a pointer to a (struct bpc_fileinfo) object. The + * contents of this objects may be overwritten with subsequent calls to + * bpc_get_head() for the same handle. NULL is returned on error or when no + * more objects exist in the stream. + * + * NOTES: + * This function gets the header of a GET_REPLY from the handle and sets + * them in the (struct bpc_fileinfo) value that it returns. + * + * You should then call bpc_get() if the header indicates that this + * represents this is a regular file. + * + * EXAMPLES: + * + * // Get an item from an open LIST command + * struct bpc_fileinfo *fileinfo; + * + * fileinfo = bpc_get_head(bpc_handle); + * + * if (!fileinfo) { + * return(-1); + * } + * + */ +struct bpc_fileinfo *bpc_get_head(BPC_CONN *handle) { + uint32_t blocknum; + struct bpc_fileinfo *ret; + + if (!handle) { + CHECKPOINT; + return(NULL); + } + + if (handle->state != BPC_CMD_GET) { + CHECKPOINT; + return(NULL); + } + + /* + * The "GET" operation is the same as the "LIST" operation, except + * data will follow if the type is BPC_FILE_REG. + */ + ret = _bpc_list(handle, BPC_CMD_GET); + + if (!ret) { + CHECKPOINT; + return(NULL); + } + + if (ret->type != BPC_FILE_REG) { + if (!_bpc_client_read(handle->fd, + BPC_CDT_UINT32, &blocknum, + BPC_CDT_END)) { + CHECKPOINT; + return(NULL); + } + + if (blocknum != 0xffffffff) { + CHECKPOINT; + return(NULL); + } + + CHECKPOINT; + return(ret); + } + + handle->state = BPC_CMD_GET_DATA; + + return(ret); +} + +/* + * SYNOPSIS: + * ssize_t bpc_get( + * BPC_CONN *handle, + * char *buf, + * size_t count + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * void *buf Pointer to a buffer to return data into + * size_t count Size of buffer + * + * RETURN VALUE: + * This function returns the number of bytes written to the memory pointed to + * by `buf' on success. On error -1 is returned. + * + * NOTES: + * + * EXAMPLES: + * + * // Get an item from an open LIST command + * ssize_t ret; + * char buf[20]; + * + * ret = bpc_get(bpc_handle, buf, sizeof(buf)); + * + * if (ret < 0) { + * return(-1); + * } + * + */ +ssize_t bpc_get(BPC_CONN *handle, void *buf, size_t count) { + struct bpc_transfer *tinfo; + ssize_t recv_ret; + uint32_t bytes_left; + uint32_t sinkbytes = 0; + int sockid; + + if (!handle) { + CHECKPOINT; + return(-1); + } + + if (handle->state != BPC_CMD_GET_DATA) { + CHECKPOINT; + return(-1); + } + + sockid = handle->fd; + + tinfo = &handle->tinfo; + + if (tinfo->blockoffset == 0) { + if (tinfo->currblocknum == tinfo->idealblocknum || tinfo->idealblocknum == -1) { + if (!_bpc_client_read(sockid, + BPC_CDT_UINT32, &tinfo->currblocknum, + BPC_CDT_END)) { + CHECKPOINT; + return(-1); + } + + if (tinfo->currblocknum == 0xffffffff) { + handle->state = BPC_CMD_GET; + CHECKPOINT; + return(0); + } + } + + if (tinfo->currblocknum == 0) { + tinfo->idealblocknum = 0; + } else { + tinfo->idealblocknum++; + } + } + + bytes_left = tinfo->blocksize - tinfo->blockoffset; + + if (count > bytes_left) { + count = bytes_left; + } + + if ((tinfo->idealblocknum * tinfo->blocksize + tinfo->blockoffset) > tinfo->filesize) { + count = 0; + sinkbytes = tinfo->blocksize - tinfo->blockoffset; + } else { + if ((tinfo->idealblocknum * tinfo->blocksize + tinfo->blockoffset + count) > tinfo->filesize) { + count = tinfo->filesize - (tinfo->idealblocknum * tinfo->blocksize + tinfo->blockoffset); + sinkbytes = tinfo->blocksize - count; + } + } + + if (tinfo->currblocknum != tinfo->idealblocknum) { + memset(buf, '\0', count); + recv_ret = count; + } else { + recv_ret = recv(sockid, buf, count, MSG_WAITALL); + + if (sinkbytes) { + if (!_bpc_client_read(sockid, + BPC_CDT_SINK, (ssize_t) sinkbytes, + BPC_CDT_END)) { + CHECKPOINT; + return(-1); + } + } + } + + if (recv_ret < 0) { + CHECKPOINT; + return(-1); + } + + tinfo->blockoffset += recv_ret + sinkbytes; + + if (tinfo->blockoffset == tinfo->blocksize) { + tinfo->blockoffset = 0; + } + + CHECKPOINT; + return(recv_ret); +} + +int bpc_copy(BPC_CONN *handle, bpc_mode_t mode, int fd) { + char buf[32768]; + ssize_t read_ret, write_ret; + int write_fail_count = 0; + int retval = 1; + + while (1) { + read_ret = bpc_get(handle, buf, sizeof(buf)); + + if (read_ret == 0) { + break; + } + + if (read_ret < 0) { + retval = 0; + break; + } + + while (read_ret) { + switch (mode) { + case BPC_MODE_WRITE: + write_ret = write(fd, buf, read_ret); + break; + case BPC_MODE_SEND: + write_ret = send(fd, buf, read_ret, 0); + break; + default: + write_ret = -1; + } + + + if (write_ret < 0) { + retval = 0; + break; + } + + if (write_ret == 0) { + write_fail_count++; + } else { + write_fail_count = 0; + } + + if (write_fail_count >= 10) { + retval = 0; + break; + } + + read_ret -= write_ret; + } + } + + CHECKPOINT; + return(retval); +} + +int bpc_rdiffget(BPC_CONN *handle, const char *remote_src, const char *dest) { + backuppc_hashid_t hashalgo = BPC_HASH_MD4; + struct stat stbuf; + uint64_t filesize; + uint32_t blocksize; + uint32_t num_hash_ents, hash_ent, hash_ent_size, hash_list_size; + ssize_t read_ret; + char buf[BPC_MAX_RDIFF_BLOCKSIZE]; + void *hash_handle; + int stat_ret; + int sockid; + int fd; + + if (!handle) { + return(0); + } + + sockid = handle->fd; + + stat_ret = stat(dest, &stbuf); + if (stat_ret < 0) { + filesize = 0xffffffffffffffffLLU; + blocksize = 0; + num_hash_ents = 0; + } else { + filesize = stbuf.st_size; + + /* + * Determine the block size: + * 0 bytes to 20 MBytes: 2 KBytes + * 20 MBytes to 1 GByte: 4 KBytes + * 1 GByte to Infinity: 8 KBytes + */ + if (filesize < (20 * 1024 * 1024)) { + blocksize = 2048; + } else if (filesize < (1024 * 1024 * 1024)) { + blocksize = 4096; + } else { + blocksize = BPC_MAX_RDIFF_BLOCKSIZE; + } + + if (blocksize > BPC_MAX_RDIFF_BLOCKSIZE) { + blocksize = BPC_MAX_RDIFF_BLOCKSIZE; + } + + num_hash_ents = (filesize + blocksize - 1) / blocksize; + } + + switch (hashalgo) { + case BPC_HASH_NONE: + break; + case BPC_HASH_MD5: + hash_ent_size = (128 / 8); + hash_handle = NULL; + break; + case BPC_HASH_MD4: + hash_ent_size = (128 / 8); + hash_handle = NULL; + break; + case BPC_HASH_SHA1: + hash_ent_size = (160 / 8); + hash_handle = malloc(sizeof(SHA1_CTX)); + break; + case BPC_HASH_BPC: + hash_ent_size = (128 / 8); + hash_handle = NULL; + break; + } + + hash_list_size = num_hash_ents * hash_ent_size; + + if (!_bpc_client_write(sockid, + BPC_CDT_UINT8, (uint8_t) BPC_CMD_RDGET, + BPC_CDT_UINT64, (uint64_t) filesize, + BPC_CDT_UINT32, (uint32_t) blocksize, + BPC_CDT_UINT8, (uint8_t) hashalgo, + BPC_CDT_UINT32, (uint32_t) hash_list_size, + BPC_CDT_UINT32, (uint32_t) strlen(remote_src), + BPC_CDT_STRING, (char *) remote_src, + BPC_CDT_END)) { + return(0); + } + + fd = open(dest, O_RDONLY); + + if (fd < 0) { + return(0); + } + + for (hash_ent = 0; hash_ent < num_hash_ents; hash_ent++) { + read_ret = read(fd, buf, blocksize); + if (read_ret < 0) { + read_ret = 0; + } + + if (read_ret == 0) { + CHECKPOINT; + } + + switch (hashalgo) { + case BPC_HASH_NONE: + break; + case BPC_HASH_SHA1: + SHA1Init(hash_handle); + SHA1Update(hash_handle, buf, read_ret); +// SHA1Final(digest[20], hash_handle); + break; + case BPC_HASH_MD5: + case BPC_HASH_MD4: + case BPC_HASH_BPC: + break; + } + } + + close(fd); + + if (hash_handle) { + free(hash_handle); + } + + return(1); +} + +int bpc_copyfile(BPC_CONN *handle, struct bpc_fileinfo *src, const char *dest, int preserve) { + int fd; + int retval = 0; + int sys_ret; + + switch (src->type) { + case BPC_FILE_DIR: + backuppc_mkdir(dest); + retval = 1; + break; + case BPC_FILE_SYMLINK: +#ifdef HAVE_SYMLINK + sys_ret = symlink(src->linkdest, dest); + if (sys_ret == 0) { + retval = 1; + } +#endif + break; + case BPC_FILE_HRDLINK: + sys_ret = link(src->linkdest, dest); + if (sys_ret == 0) { + retval = 1; + } + break; + case BPC_FILE_CDEV: + case BPC_FILE_BDEV: + case BPC_FILE_SOCKET: + case BPC_FILE_FIFO: + case BPC_FILE_UNKNOWN: + CHECKPOINT; + return(0); + case BPC_FILE_REG: + /* + * Regular files are handled seperately + */ + break; + } + + if (src->type != BPC_FILE_REG) { + if (retval && preserve) { + chmod(dest, src->mode); +#ifdef HAVE_LCHOWN + lchown(dest, src->uid, src->gid); +#else + chown(dest, src->uid, src->gid); +#endif +#ifdef HAVE_UTIME +// utime(...) +#endif + } + CHECKPOINT; + return(retval); + } + + + /* + * Handle the regular files using either RDIFF or GET. + */ + if (access(dest, F_OK) == 0 && 0 /* XXX: RGET NOT IMPLEMENTED */) { + /* + * Do RDIFF + */ + } else { + /* + * Copy the entire file. + */ + fd = open(dest, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600); + + if (bpc_copy(handle, BPC_MODE_WRITE, fd)) { + retval = 1; + } + + close(fd); + } + if (preserve) { + chmod(dest, src->mode); + chown(dest, src->uid, src->gid); +#ifdef HAVE_UTIME +// utime(...) +#endif + } + + CHECKPOINT; + return(retval); +} + +/* + * SYNOPSIS: + * BPC_CONN *bpc_connect( + * const char *host, + * const int port, + * const char *username, + * const char *password + * ); + * + * ARGUMENTS: + * const char *host BackupPCd host to connect to + * const int port Port to connect to host on (default if == 0) + * const char *username (optional) Username to authenticate with + * const char *password (optional) Password to authenticate with + * + * RETURN VALUE: + * This function returns NULL on failure, a pointer to a (BPC_CONN) on success. + * + * NOTES: + * + * EXAMPLES: + * + */ +BPC_CONN *bpc_connect(const char *host, const int port, const char *username, const char *password) { + BPC_CONN *ret; + int sockid; + int real_port; + + if (port == 0) { + real_port = BPC_TCP_PORT; + } else { + real_port = port; + } + + sockid = net_connect_tcp(host, real_port); + + if (sockid < 0) { + CHECKPOINT; + return(NULL); + } + + ret = malloc(sizeof(*ret)); + + if (!ret) { + close(sockid); + + CHECKPOINT; + return(NULL); + } + + ret->fd = sockid; + ret->state = BPC_CMD_NONE; + + if (username && password) { + if (!bpc_auth(ret, username, password)) { + close(ret->fd); + free(ret); + + CHECKPOINT; + return(NULL); + } + } + + CHECKPOINT; + return(ret); +} + +/* + * SYNOPSIS: + * int bpc_disconnect( + * BPC_CONN *handle + * ); + * + * ARGUMENTS: + * BPC_CONN *handle Connection handle + * + * RETURN VALUE: + * This function returns -1 on failure, 0 on success. + * + * NOTES: + * + * EXAMPLES: + * + */ +int bpc_disconnect(BPC_CONN *handle) { + int close_ret; + + if (!handle) { + CHECKPOINT; + return(-1); + } + + if (handle->fd < 0) { + CHECKPOINT; + return(0); + } + + close_ret = net_close(handle->fd); + + if (close_ret < 0) { + CHECKPOINT; + return(close_ret); + } + + free(handle); + + CHECKPOINT; + return(0); +} diff --git a/libbackuppcd.h b/libbackuppcd.h new file mode 100644 index 0000000..bee15f8 --- /dev/null +++ b/libbackuppcd.h @@ -0,0 +1,102 @@ +#ifndef _LIBBACKUPPCD_H +#define _LIBBACKUPPCD_H 1 +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#include +#include + +/* + * These define symbols to determine whether or not write() or send() should + * be used to transfer data to a descriptor. write() may not be usable on + * socket descriptors, and send() will never work for file descriptors. + */ +typedef enum { + BPC_MODE_WRITE, + BPC_MODE_SEND +} bpc_mode_t; + +/* + * This structure is used to give access to file information from a GET or + * LIST operation. + */ +struct bpc_fileinfo { + backuppc_filetype_t type; + unsigned long long size; + unsigned char hash_md4[16]; + unsigned char hash_md5[16]; + unsigned char hash_bpc[16]; + unsigned char hash_sha1[20]; + time_t mtime; + time_t ctime; + long dev_major; + long dev_minor; + long uid; + long gid; + char owner_group[BPC_MAXPATH_LEN]; + char owner_user[BPC_MAXPATH_LEN]; + char linkdest[BPC_MAXPATH_LEN]; + char name[BPC_MAXPATH_LEN]; + int mode; +}; + +/* + * The BPC_CONN type is used as a handle to represent an individual connection + * a BackupPCd Server. + */ +typedef struct bpc_conn BPC_CONN; + +/* + * LibBackupPCd API + */ + +/* + * Operations associated with connection management + */ +BPC_CONN *bpc_connect(const char *host, const int port, const char *username, const char *password); +int bpc_disconnect(BPC_CONN *handle); + +/* + * Operations associated with authentication + */ +int bpc_auth(BPC_CONN *handle, const char *username, const char *password); + +/* + * Operations associated with getting a listing of files + */ +int bpc_list_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat); +struct bpc_fileinfo *bpc_list(BPC_CONN *handle); +int bpc_list_close(BPC_CONN *handle); + +/* + * Operations associated with transfering files + */ +int bpc_get_open(BPC_CONN *handle, const char *rootpath, const int recursive, backuppc_hashid_t hashalgo, const char *exclpat, const char *inclpat); +struct bpc_fileinfo *bpc_get_head(BPC_CONN *handle); +ssize_t bpc_get(BPC_CONN *handle, void *buf, size_t count); +int bpc_copy(BPC_CONN *handle, bpc_mode_t mode, int fd); +int bpc_copyfile(BPC_CONN *handle, struct bpc_fileinfo *src, const char *dest, int preserve); +int bpc_get_close(BPC_CONN *handle); + +#endif diff --git a/link.c b/link.c new file mode 100644 index 0000000..de4ab9f --- /dev/null +++ b/link.c @@ -0,0 +1,22 @@ +#include "compat.h" +#include "link.h" + +#ifndef HAVE_LINK + +int link(const char *oldpath, const char *newpath) { + int retval = -1; +#ifdef _USE_WIN32_ +# if (_WIN32_WINNT >= 0x0500) + BOOL chl_retval; + + chl_retval = CreateHardLink(newpath, oldpath, NULL); + + if (chl_retval) { + retval = 0; + } +# endif +#endif + return(retval); +} + +#endif diff --git a/link.h b/link.h new file mode 100644 index 0000000..323ee1e --- /dev/null +++ b/link.h @@ -0,0 +1,15 @@ +#include "compat.h" +#include "backuppcd.h" +#include "backuppcd-common.h" + +#ifndef HAVE_LINK +# ifndef _RSK_LINK_H +# define _RSK_LINK_H 1 +# include "compat.h" +# include "backuppcd.h" +# include "backuppcd-common.h" + +int link(const char *oldpath, const char *newpath); + +# endif /* _RSK_LINK_H */ +#endif /* HAVE_LINK */ diff --git a/md4.c b/md4.c new file mode 100644 index 0000000..dba8504 --- /dev/null +++ b/md4.c @@ -0,0 +1,269 @@ +/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm + */ + +/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved. + + License to copy and use this software is granted provided that it + is identified as the "RSA Data Security, Inc. MD4 Message-Digest + Algorithm" in all material mentioning or referencing this software + or this function. + + License is also granted to make and use derivative works provided + that such works are identified as "derived from the RSA Data + Security, Inc. MD4 Message-Digest Algorithm" in all material + mentioning or referencing the derived work. + + RSA Data Security, Inc. makes no representations concerning either + the merchantability of this software or the suitability of this + software for any particular purpose. It is provided "as is" + without express or implied warranty of any kind. + + These notices must be retained in any copies of any part of this + documentation and/or software. + */ + +#include "md4.h" + +/* Constants for MD4Transform routine. + */ +#define S11 3 +#define S12 7 +#define S13 11 +#define S14 19 +#define S21 3 +#define S22 5 +#define S23 9 +#define S24 13 +#define S31 3 +#define S32 9 +#define S33 11 +#define S34 15 + +static void MD4Transform(uint32_t [4], unsigned char [64]); +static void Encode(unsigned char *, uint32_t *, unsigned int); +static void Decode(uint32_t *, unsigned char *, unsigned int); + +static unsigned char PADDING[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G and H are basic MD4 functions. + */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) + +/* ROTATE_LEFT rotates x left n bits. + */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG and HH are transformations for rounds 1, 2 and 3 */ +/* Rotation is separate from addition to prevent recomputation */ +#define FF(a, b, c, d, x, s) { \ + (a) += F ((b), (c), (d)) + (x); \ + (a) = ROTATE_LEFT ((a), (s)); \ + } +#define GG(a, b, c, d, x, s) { \ + (a) += G ((b), (c), (d)) + (x) + (uint32_t)0x5a827999; \ + (a) = ROTATE_LEFT ((a), (s)); \ + } +#define HH(a, b, c, d, x, s) { \ + (a) += H ((b), (c), (d)) + (x) + (uint32_t)0x6ed9eba1; \ + (a) = ROTATE_LEFT ((a), (s)); \ + } + +/* MD4 initialization. Begins an MD4 operation, writing a new context. + */ +void rsaref_MD4Init (context) +rsaref_MD4_CTX *context; /* context */ +{ + context->count[0] = context->count[1] = 0; + + /* Load magic initialization constants. + */ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* MD4 block update operation. Continues an MD4 message-digest + operation, processing another message block, and updating the + context. + */ +void rsaref_MD4Update (context, input, inputLen) +rsaref_MD4_CTX *context; /* context */ +unsigned char *input; /* input block */ +unsigned int inputLen; /* length of input block */ +{ + unsigned int i, index, partLen; + + /* Compute number of bytes mod 64 */ + index = (unsigned int)((context->count[0] >> 3) & 0x3F); + /* Update number of bits */ + if ((context->count[0] += ((uint32_t)inputLen << 3)) + < ((uint32_t)inputLen << 3)) + context->count[1]++; + context->count[1] += ((uint32_t)inputLen >> 29); + + partLen = 64 - index; + + /* Transform as many times as possible. + */ + if (inputLen >= partLen) { + memcpy + ((unsigned char *)&context->buffer[index], (unsigned char *)input, partLen); + MD4Transform (context->state, context->buffer); + + for (i = partLen; i + 63 < inputLen; i += 64) + MD4Transform (context->state, &input[i]); + + index = 0; + } + else + i = 0; + + /* Buffer remaining input */ + memcpy + ((unsigned char *)&context->buffer[index], (unsigned char *)&input[i], + inputLen-i); +} + +/* MD4 finalization. Ends an MD4 message-digest operation, writing the + the message digest and zeroizing the context. + */ +void rsaref_MD4Final (digest, context) +unsigned char digest[16]; /* message digest */ +rsaref_MD4_CTX *context; /* context */ +{ + unsigned char bits[8]; + unsigned int index, padLen; + + /* Save number of bits */ + Encode (bits, context->count, 8); + + /* Pad out to 56 mod 64. + */ + index = (unsigned int)((context->count[0] >> 3) & 0x3f); + padLen = (index < 56) ? (56 - index) : (120 - index); + rsaref_MD4Update (context, PADDING, padLen); + + /* Append length (before padding) */ + rsaref_MD4Update (context, bits, 8); + /* Store state in digest */ + Encode (digest, context->state, 16); + + /* Zeroize sensitive information. + */ + memset ((unsigned char *)context, 0, sizeof (*context)); +} + +/* MD4 basic transformation. Transforms state based on block. + */ +static void MD4Transform (state, block) +uint32_t state[4]; +unsigned char block[64]; +{ + uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + + Decode (x, block, 64); + + /* Round 1 */ + FF (a, b, c, d, x[ 0], S11); /* 1 */ + FF (d, a, b, c, x[ 1], S12); /* 2 */ + FF (c, d, a, b, x[ 2], S13); /* 3 */ + FF (b, c, d, a, x[ 3], S14); /* 4 */ + FF (a, b, c, d, x[ 4], S11); /* 5 */ + FF (d, a, b, c, x[ 5], S12); /* 6 */ + FF (c, d, a, b, x[ 6], S13); /* 7 */ + FF (b, c, d, a, x[ 7], S14); /* 8 */ + FF (a, b, c, d, x[ 8], S11); /* 9 */ + FF (d, a, b, c, x[ 9], S12); /* 10 */ + FF (c, d, a, b, x[10], S13); /* 11 */ + FF (b, c, d, a, x[11], S14); /* 12 */ + FF (a, b, c, d, x[12], S11); /* 13 */ + FF (d, a, b, c, x[13], S12); /* 14 */ + FF (c, d, a, b, x[14], S13); /* 15 */ + FF (b, c, d, a, x[15], S14); /* 16 */ + + /* Round 2 */ + GG (a, b, c, d, x[ 0], S21); /* 17 */ + GG (d, a, b, c, x[ 4], S22); /* 18 */ + GG (c, d, a, b, x[ 8], S23); /* 19 */ + GG (b, c, d, a, x[12], S24); /* 20 */ + GG (a, b, c, d, x[ 1], S21); /* 21 */ + GG (d, a, b, c, x[ 5], S22); /* 22 */ + GG (c, d, a, b, x[ 9], S23); /* 23 */ + GG (b, c, d, a, x[13], S24); /* 24 */ + GG (a, b, c, d, x[ 2], S21); /* 25 */ + GG (d, a, b, c, x[ 6], S22); /* 26 */ + GG (c, d, a, b, x[10], S23); /* 27 */ + GG (b, c, d, a, x[14], S24); /* 28 */ + GG (a, b, c, d, x[ 3], S21); /* 29 */ + GG (d, a, b, c, x[ 7], S22); /* 30 */ + GG (c, d, a, b, x[11], S23); /* 31 */ + GG (b, c, d, a, x[15], S24); /* 32 */ + + /* Round 3 */ + HH (a, b, c, d, x[ 0], S31); /* 33 */ + HH (d, a, b, c, x[ 8], S32); /* 34 */ + HH (c, d, a, b, x[ 4], S33); /* 35 */ + HH (b, c, d, a, x[12], S34); /* 36 */ + HH (a, b, c, d, x[ 2], S31); /* 37 */ + HH (d, a, b, c, x[10], S32); /* 38 */ + HH (c, d, a, b, x[ 6], S33); /* 39 */ + HH (b, c, d, a, x[14], S34); /* 40 */ + HH (a, b, c, d, x[ 1], S31); /* 41 */ + HH (d, a, b, c, x[ 9], S32); /* 42 */ + HH (c, d, a, b, x[ 5], S33); /* 43 */ + HH (b, c, d, a, x[13], S34); /* 44 */ + HH (a, b, c, d, x[ 3], S31); /* 45 */ + HH (d, a, b, c, x[11], S32); /* 46 */ + HH (c, d, a, b, x[ 7], S33); /* 47 */ + HH (b, c, d, a, x[15], S34); /* 48 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information. + */ + memset ((unsigned char *)x, 0, sizeof (x)); +} + +/* Encodes input (uint32_t) into output (unsigned char). Assumes len is + a multiple of 4. + */ +static void Encode (output, input, len) +unsigned char *output; +uint32_t *input; +unsigned int len; +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) { + output[j] = (unsigned char)(input[i] & 0xff); + output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); + output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); + output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + } +} + +/* Decodes input (unsigned char) into output (uint32_t). Assumes len is + a multiple of 4. + */ +static void Decode (output, input, len) + +uint32_t *output; +unsigned char *input; +unsigned int len; +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) + output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) | + (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24); +} diff --git a/md4.h b/md4.h new file mode 100644 index 0000000..c29a3fa --- /dev/null +++ b/md4.h @@ -0,0 +1,42 @@ +#ifndef _RSA_MD4_H +#define _RSA_MD4_H 1 + +/* MD4.H - header file for MD4C.C + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All + rights reserved. + + License to copy and use this software is granted provided that it + is identified as the "RSA Data Security, Inc. MD4 Message-Digest + Algorithm" in all material mentioning or referencing this software + or this function. + + License is also granted to make and use derivative works provided + that such works are identified as "derived from the RSA Data + Security, Inc. MD4 Message-Digest Algorithm" in all material + mentioning or referencing the derived work. + + RSA Data Security, Inc. makes no representations concerning either + the merchantability of this software or the suitability of this + software for any particular purpose. It is provided "as is" + without express or implied warranty of any kind. + + These notices must be retained in any copies of any part of this + documentation and/or software. + */ + +#include "compat.h" + +/* MD4 context. */ +typedef struct { + uint32_t state[4]; /* state (ABCD) */ + uint32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */ + unsigned char buffer[64]; /* input buffer */ +} rsaref_MD4_CTX; + +void rsaref_MD4Init(rsaref_MD4_CTX *); +void rsaref_MD4Update(rsaref_MD4_CTX *, unsigned char *, unsigned int); +void rsaref_MD4Final(unsigned char [16], rsaref_MD4_CTX *); + +#endif diff --git a/md5.c b/md5.c new file mode 100644 index 0000000..216cab1 --- /dev/null +++ b/md5.c @@ -0,0 +1,381 @@ +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.c is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +#include "md5.h" +#include + +#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ +#ifdef ARCH_IS_BIG_ENDIAN +# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) +#else +# define BYTE_ORDER 0 +#endif + +#define T_MASK ((md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + + +static void +md5_process(ld_MD5_CTX *pms, const md5_byte_t *data /*[64]*/) +{ + md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; + md5_word_t t; +#if BYTE_ORDER > 0 + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; +#else + /* Define storage for little-endian or both types of CPUs. */ + md5_word_t xbuf[16]; + const md5_word_t *X; +#endif + + { +#if BYTE_ORDER == 0 + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const md5_byte_t *)&w)) /* dynamic little-endian */ +#endif +#if BYTE_ORDER <= 0 /* little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - (const md5_byte_t *)0) & 3)) { + /* data are properly aligned */ + X = (const md5_word_t *)data; + } else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } +#endif +#if BYTE_ORDER == 0 + else /* dynamic big-endian */ +#endif +#if BYTE_ORDER >= 0 /* big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const md5_byte_t *xp = data; + int i; + +# if BYTE_ORDER == 0 + X = xbuf; /* (dynamic only) */ +# else +# define xbuf X /* (static only) */ +# endif + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } +#endif + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + + /* Round 2. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + + /* Round 3. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + + /* Round 4. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +void +ld_MD5Init(ld_MD5_CTX *pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +void +ld_MD5Update(ld_MD5_CTX *pms, const md5_byte_t *data, int nbytes) +{ + const md5_byte_t *p = data; + int left = nbytes; + int offset = (pms->count[0] >> 3) & 63; + md5_word_t nbits = (md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += nbytes >> 29; + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +void +ld_MD5Final(md5_byte_t digest[16], ld_MD5_CTX *pms) +{ + static const md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + ld_MD5Update(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + ld_MD5Update(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} diff --git a/md5.h b/md5.h new file mode 100644 index 0000000..a1a1722 --- /dev/null +++ b/md5.h @@ -0,0 +1,107 @@ +/* + Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.h is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Removed support for non-ANSI compilers; removed + references to Ghostscript; clarified derivation from RFC 1321; + now handles byte order either statically or dynamically. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); + added conditionalization for C++ compilation from Martin + Purschke . + 1999-05-03 lpd Original version. + */ + +#ifndef md5_INCLUDED +# define md5_INCLUDED + +#include "compat.h" + +/* + * This package supports both compile-time and run-time determination of CPU + * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be + * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is + * defined as non-zero, the code will be compiled to run only on big-endian + * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to + * run on either big- or little-endian CPUs, but will run slightly less + * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. + */ + +/* + * Whether the arch is big-endian is determined by the "configure" script + * -- rsk + */ +#ifdef WORDS_BIGENDIAN +#define ARCH_IS_BIG_ENDIAN 0 +#else +#define ARCH_IS_BIG_ENDIAN 1 +#endif + +/* + * Use the C99 standard exact-width integer types. + * -- rsk + */ +typedef uint8_t md5_byte_t; /* 8-bit byte */ +typedef uint32_t md5_word_t; /* 32-bit word */ + +/* Define the state of the MD5 Algorithm. */ +typedef struct md5_state_s { + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ +} ld_MD5_CTX; + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Initialize the algorithm. */ +void ld_MD5Init(ld_MD5_CTX *pms); + +/* Append a string to the message. */ +void ld_MD5Update(ld_MD5_CTX *pms, const md5_byte_t *data, int nbytes); + +/* Finish the message and return the digest. */ +void ld_MD5Final(md5_byte_t digest[16], ld_MD5_CTX *pms); + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + +#endif /* md5_INCLUDED */ diff --git a/net.c b/net.c new file mode 100644 index 0000000..5eb5348 --- /dev/null +++ b/net.c @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +/* + * Network related functions + */ +#include "compat.h" +#include "net.h" + +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_SYS_STAT_H +#include +#endif +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include + +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_ARPA_INET_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif +#ifdef HAVE_ERRNO_H +#include +#endif +#ifdef HAVE_STDIO_H +#include +#endif + +#ifndef SHUT_RDWR +#define SHUT_RDWR 2 +#endif + +/* Do things required for network access. */ +static int net_init(void) { +#ifdef _USE_WIN32_ + static int net_init_called = 0; + WSADATA wsaData; + + if (net_init_called) { + return(0); + } + + if (WSAStartup(MAKEWORD(2, 0), &wsaData)!=0) { + return(-1); + } + if (wsaData.wVersion!=MAKEWORD(2, 0)) { + /* Cleanup Winsock stuff */ + WSACleanup(); + return(-1); + } + + net_init_called = 1; +#endif + return(0); +} + + +/* + * Create a listening port on tcp port PORT + */ +int net_listen(const int port) { + struct sockaddr_in localname; + int sockFd; + + net_init(); + + sockFd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); + localname.sin_family = AF_INET; + localname.sin_port = htons(port); + localname.sin_addr.s_addr = INADDR_ANY; + + if (sockFd < 0) { + return(-1); + } + + if (bind(sockFd, (struct sockaddr *) &localname, sizeof(localname)) < 0) { + return(-1); + } + + if (listen(sockFd, 1024) < 0) { + return(-1); + } + + return(sockFd); +} + + +int net_connect_tcp(const char *host, const int port) { + int sockid; + struct hostent *hostinfo; + struct sockaddr_in sock; + + net_init(); + +#ifdef HAVE_INET_ATON + if (!inet_aton(host,&sock.sin_addr)) { +#else +#ifdef HAVE_INET_ADDR + if ( (sock.sin_addr.s_addr=inet_addr(host) )==-1) { +#else + { +#endif +#endif + if ((hostinfo=gethostbyname(host))==NULL) return(-EPERM); + memcpy(&sock.sin_addr.s_addr,hostinfo->h_addr_list[0],hostinfo->h_length); + } + + sock.sin_family=AF_INET; + sock.sin_port=htons(port); + if ((sockid=socket(AF_INET, SOCK_STREAM, 0))<0) { + return(-EIO); + } + if (connect(sockid, (struct sockaddr *) &sock, sizeof(sock))<0) { + close(sockid); + return(-EIO); + } + return(sockid); +} + +int net_close(const int sockid) { + shutdown(sockid, SHUT_RDWR); + return(close(sockid)); +} diff --git a/net.h b/net.h new file mode 100644 index 0000000..eb3c57e --- /dev/null +++ b/net.h @@ -0,0 +1,41 @@ +#ifndef _RSK_NET_H +#define _RSK_NET_H + +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#include "compat.h" + +#ifdef HAVE_SYS_TYPES_H +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif + +int net_listen(const int port); +int net_connect_tcp(const char *host, const int port); +int net_close(const int sockid); + +#endif diff --git a/ntohll.c b/ntohll.c new file mode 100644 index 0000000..a42af8c --- /dev/null +++ b/ntohll.c @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#include "compat.h" + +#ifndef HAVE_NTOHLL + +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_ENDIAN_H +#include +#endif + +#ifndef __BIG_ENDIAN +#define __BIG_ENDIAN 4321 +#endif +#ifndef __LITTLE_ENDIAN +#define __LITTLE_ENDIAN 1234 +#endif + +#ifndef __BYTE_ORDER +#ifdef WORDS_BIGENDIAN +#define __BYTE_ORDER __BIG_ENDIAN +#else +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#endif + +#include "ntohll.h" + +uint64_t ntohll(uint64_t n) { + uint64_t retval; + +#if __BYTE_ORDER == __BIG_ENDIAN + retval = n; +#else + retval = ((uint64_t) ntohl(n & 0xFFFFFFFFLLU)) << 32; + retval |= ntohl((n & 0xFFFFFFFF00000000LLU) >> 32); +#endif + return(retval); +} + +#endif diff --git a/ntohll.h b/ntohll.h new file mode 100644 index 0000000..4f5c02f --- /dev/null +++ b/ntohll.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + + +#ifndef _RSK_NTOHLL_H +#define _RSK_NTOHLL_H + +#include "compat.h" + +#ifndef HAVE_NTOHLL + +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif +#ifdef HAVE_ENDIAN_H +#include +#endif + +uint64_t ntohll(uint64_t n); + +#endif +#endif diff --git a/sha1.c b/sha1.c new file mode 100644 index 0000000..9b81fbe --- /dev/null +++ b/sha1.c @@ -0,0 +1,221 @@ +/* + SHA-1 in C + By Steve Reid + 100% Public Domain + +Test Vectors (from FIPS PUB 180-1) +"abc" + A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D +"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" + 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 +A million repetitions of "a" + 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F +*/ + +/* #define LITTLE_ENDIAN * This should be #define'd if true. */ +/* #define SHA1HANDSOFF * Copies data before messing with it. */ + +#include "compat.h" + +#define SHA1HANDSOFF 1 +#ifdef HAVE_STDIO_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif + +#include "sha1.h" + +#ifndef __BIG_ENDIAN +#define __BIG_ENDIAN 4321 +#endif +#ifndef __LITTLE_ENDIAN +#define __LITTLE_ENDIAN 1234 +#endif + +#ifndef __BYTE_ORDER +#ifdef WORDS_BIGENDIAN +#define __BYTE_ORDER __BIG_ENDIAN +#else +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#endif + +#if __BYTE_ORDER == __BIG_ENDIAN +#ifndef BIG_ENDIAN +#define BIG_ENDIAN 1 +#endif +#undef LITTLE_ENDIAN +#else +#ifndef LITTLE_ENDIAN +#define LITTLE_ENDIAN 1 +#endif +#undef BIG_ENDIAN +#endif + +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) + +/* blk0() and blk() perform the initial expand. */ +/* I got the idea of expanding during the round function from SSLeay */ +#ifdef LITTLE_ENDIAN +#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ + |(rol(block->l[i],8)&0x00FF00FF)) +#else +#define blk0(i) block->l[i] +#endif +#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ + ^block->l[(i+2)&15]^block->l[i&15],1)) + +/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); + + +/* Hash a single 512-bit block. This is the core of the algorithm. */ + +void SHA1Transform(unsigned long state[5], unsigned char buffer[64]) +{ +unsigned long a, b, c, d, e; +typedef union { + unsigned char c[64]; + unsigned long l[16]; +} CHAR64LONG16; +CHAR64LONG16* block; +#ifdef SHA1HANDSOFF +static unsigned char workspace[64]; + block = (CHAR64LONG16*)workspace; + memcpy(block, buffer, 64); +#else + block = (CHAR64LONG16*)buffer; +#endif + /* Copy context->state[] to working vars */ + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + /* 4 rounds of 20 operations each. Loop unrolled. */ + R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); + R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); + R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); + R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); + R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); + R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); + R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); + R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); + R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); + R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); + R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); + R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); + R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); + R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); + R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); + R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); + R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); + R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); + R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); + R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); + /* Add the working vars back into context.state[] */ + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + /* Wipe variables */ + a = b = c = d = e = 0; +} + + +/* SHA1Init - Initialize new context */ + +void SHA1Init(SHA1_CTX* context) +{ + /* SHA1 initialization constants */ + context->state[0] = 0x67452301; + context->state[1] = 0xEFCDAB89; + context->state[2] = 0x98BADCFE; + context->state[3] = 0x10325476; + context->state[4] = 0xC3D2E1F0; + context->count[0] = context->count[1] = 0; +} + + +/* Run your data through this. */ + +void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len) +{ +unsigned int i, j; + + j = (context->count[0] >> 3) & 63; + if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++; + context->count[1] += (len >> 29); + if ((j + len) > 63) { + memcpy(&context->buffer[j], data, (i = 64-j)); + SHA1Transform(context->state, context->buffer); + for ( ; i + 63 < len; i += 64) { + SHA1Transform(context->state, &data[i]); + } + j = 0; + } + else i = 0; + memcpy(&context->buffer[j], &data[i], len - i); +} + + +/* Add padding and return the message digest. */ + +void SHA1Final(unsigned char digest[20], SHA1_CTX* context) +{ +unsigned long i, j; +unsigned char finalcount[8]; + + for (i = 0; i < 8; i++) { + finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] + >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ + } + SHA1Update(context, (unsigned char *)"\200", 1); + while ((context->count[0] & 504) != 448) { + SHA1Update(context, (unsigned char *)"\0", 1); + } + SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ + for (i = 0; i < 20; i++) { + digest[i] = (unsigned char) + ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); + } + /* Wipe variables */ + i = j = 0; + memset(context->buffer, 0, 64); + memset(context->state, 0, 20); + memset(context->count, 0, 8); + memset(&finalcount, 0, 8); +#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */ + SHA1Transform(context->state, context->buffer); +#endif +} + +char *SHA1sum(char *string) { + unsigned char digest[20]; + static char ret[(sizeof(digest) * 2) + 1] = {0}; + static char hexabet[] = "0123456789abcdef"; + SHA1_CTX ctx; + int retcnt = 0, i; + + SHA1Init(&ctx); + + SHA1Update(&ctx, string, strlen(string)); + + SHA1Final(digest, &ctx); + + for (i = 0; i < sizeof(digest); i++) { + ret[retcnt++] = hexabet[(digest[i] & 0xf0) >> 4]; + ret[retcnt++] = hexabet[digest[i] & 0xf]; + } + + ret[retcnt] = '\0'; + + return(ret); +} diff --git a/sha1.h b/sha1.h new file mode 100644 index 0000000..93c8dd5 --- /dev/null +++ b/sha1.h @@ -0,0 +1,18 @@ +#ifndef _BPC_SHA1_H +#define _BPC_SHA1_H + +typedef struct { + unsigned long state[5]; + unsigned long count[2]; + unsigned char buffer[64]; +} SHA1_CTX; + +void SHA1Transform(unsigned long state[5], unsigned char buffer[64]); +void SHA1Init(SHA1_CTX* context); +void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len); +void SHA1Final(unsigned char digest[20], SHA1_CTX* context); + +/* RSK */ +char *SHA1sum(char *string); + +#endif diff --git a/strsep.c b/strsep.c new file mode 100644 index 0000000..54f836b --- /dev/null +++ b/strsep.c @@ -0,0 +1,13 @@ +/* Compliments of Jay Freeman */ + +#include + +char *strsep(char **stringp, const char *delim) { + char *ret = *stringp; + if (ret == NULL) return(NULL); /* grrr */ + if ((*stringp = strpbrk(*stringp, delim)) != NULL) { + *((*stringp)++) = '\0'; + } + return(ret); +} + diff --git a/strsep.h b/strsep.h new file mode 100644 index 0000000..1b0b235 --- /dev/null +++ b/strsep.h @@ -0,0 +1,8 @@ +/* Compliments of Jay Freeman */ + +#ifndef _REPL_STRSEP_H +#define _REPL_STRSEP_H + +char *strsep(char **stringp, const char *delim); + +#endif diff --git a/tools/.cvsignore b/tools/.cvsignore new file mode 100644 index 0000000..61081d8 --- /dev/null +++ b/tools/.cvsignore @@ -0,0 +1,2 @@ +file_sync +.*.swp diff --git a/tools/file_sync.c b/tools/file_sync.c new file mode 100644 index 0000000..6986f1e --- /dev/null +++ b/tools/file_sync.c @@ -0,0 +1,585 @@ +#include "compat.h" +#include "md4.h" +#include "net.h" + +#ifdef HAVE_SIGNAL_H +#include +#endif +#ifndef HAVE_LIMITS_H +#include +#endif + +#ifndef INT_MAX +#define INT_MAX (0x7fffffff) +#endif + +#ifndef O_LARGEFILE +#define O_LARGEFILE 0 +#endif + +uint64_t net_bytesout = 0; +uint64_t net_bytesin = 0; + +extern char *optarg; +extern int optind, opterr, optopt; + +static int print_help(int ret) { + fprintf(stderr, "Usage: file_sync -t []\n"); + fprintf(stderr, "Usage: file_sync -r \n"); + return(ret); +} + +#if 0 +static void print_hash(FILE *fp, const unsigned char *hash) { + int i; + + for (i = 0; i < 16; i++) { + fprintf(fp, "%x", hash[i] >> 4); + fprintf(fp, "%x", hash[i] & 0xf); + } + + return; +} +#endif + +static ssize_t read_large(int fd, char *buf, size_t count) { + size_t bytestoread; + ssize_t read_ret; + ssize_t retval = 0; + + while (count) { + bytestoread = count; + + if (bytestoread >= INT_MAX) { + bytestoread = INT_MAX - 1; + } + + read_ret = read(fd, buf, bytestoread); + if (read_ret < 0) { + /* + * Only indicate an error if we have not read anything + * into the buffer. Subsequent calls to read() should + * generate the error again. Hopefully. + */ + if (retval == 0) { + retval = -1; + } + break; + } + + if (read_ret == 0) { + break; + } + + count -= read_ret; + buf += read_ret; + retval += read_ret; + } + + return(retval); +} + +static ssize_t write_large(int fd, char *buf, size_t count) { + size_t bytestowrite; + ssize_t write_ret; + ssize_t retval = 0; + + while (count) { + bytestowrite = count; + + if (bytestowrite >= INT_MAX) { + bytestowrite = INT_MAX - 1; + } + + write_ret = write(fd, buf, bytestowrite); + if (write_ret < 0) { + if (retval == 0) { + retval = -1; + } + break; + } + + if (write_ret == 0) { + break; + } + + count -= write_ret; + buf += write_ret; + retval += write_ret; + } + + return(retval); +} + +static ssize_t read_large_net(int fd, void *buf, size_t count) { + ssize_t retval; + + retval = read_large(fd, buf, count); + + if (retval > 0) { + net_bytesin += retval; + } + + return(retval); +} + +static ssize_t write_large_net(int fd, void *buf, size_t count) { + ssize_t retval; + + retval = write_large(fd, buf, count); + if (retval > 0) { + net_bytesout += retval; + } + + return(retval); +} + +int sync_transmit(const char *host, int port, const char *file, uint64_t blocksize) { + rsaref_MD4_CTX mdctx; + unsigned char md4buf[16]; + uint64_t filesize; + uint32_t blockok_size, blockidx; + uint8_t *blockok, blockok_val; + ssize_t read_ret, write_ret; + char *buf; + off_t lseek_ret; + off_t curpos, destpos; + int retval = 0; + int sockfd; + int fd; + int i; + + fd = open(file, O_RDONLY | O_LARGEFILE); + if (fd < 0) { + CHECKPOINT; + return(-1); + } + + lseek_ret = lseek(fd, 0, SEEK_END); + if (lseek_ret < 0) { + close(fd); + CHECKPOINT; + return(-1); + } + + filesize = lseek_ret; + + blockok_size = filesize / (8 * blocksize); + if ((filesize % (8 * blocksize)) != 0) { + blockok_size++; + } + + blockok = malloc(blockok_size); + if (!blockok) { + close(fd); + CHECKPOINT; + return(-1); + } + + lseek(fd, 0, SEEK_SET); + + sockfd = net_connect_tcp(host, port); + if (sockfd < 0) { + close(fd); + CHECKPOINT; + return(-1); + } + + buf = calloc(blocksize, 1); + if (!buf) { + close(fd); + close(sockfd); + CHECKPOINT; + return(-1); + } + + filesize = htonll(filesize); + blocksize = htonl(blocksize); + + write_ret = write_large_net(sockfd, &filesize, sizeof(filesize)); + if (write_ret != sizeof(filesize)) { + close(fd); + close(sockfd); + CHECKPOINT; + return(-1); + } + + write_ret = write_large_net(sockfd, &blocksize, sizeof(blocksize)); + if (write_ret != sizeof(blocksize)) { + close(fd); + close(sockfd); + CHECKPOINT; + return(-1); + } + + filesize = ntohll(filesize); + blocksize = ntohl(blocksize); + + while (1) { + read_ret = read_large(fd, buf, blocksize); + if (read_ret < 0) { + retval = -1; + CHECKPOINT; + break; + } + + if (read_ret == 0) { + CHECKPOINT; + break; + } + + rsaref_MD4Init(&mdctx); + rsaref_MD4Update(&mdctx, buf, read_ret); + rsaref_MD4Final(md4buf, &mdctx); + + write_ret = write_large_net(sockfd, md4buf, sizeof(md4buf)); + if (write_ret != sizeof(md4buf)) { + retval = -1; + CHECKPOINT; + break; + } + } + + if (retval != -1) { + read_ret = read_large_net(sockfd, blockok, blockok_size); + + if (read_ret != blockok_size) { + retval = -1; + CHECKPOINT; + } + } + + lseek(fd, 0, SEEK_SET); + curpos = 0; + + if (retval != -1) { + for (blockidx = 0; blockidx < blockok_size; blockidx++) { + for (i = 0; i < 8; i++) { + blockok_val = blockok[blockidx] & (1<= filesize) { + continue; + } + + read_ret = read_large(fd, buf, blocksize); + if (read_ret != blocksize) { + if ((lseek_ret + read_ret) != filesize || read_ret < 0) { + SPOTVAR_I(blockidx); + SPOTVAR_LLU(lseek_ret); + SPOTVAR_LLU(read_ret); + SPOTVAR_LLU(filesize); + retval = -1; + CHECKPOINT; + break; + } + } + + curpos += read_ret; + + write_ret = write_large_net(sockfd, buf, read_ret); + if (write_ret != read_ret) { + SPOTVAR_LLU(write_ret); + SPOTVAR_LLU(read_ret); + retval = -1; + CHECKPOINT; + break; + } + } + } + if (retval == -1) { + break; + } + } + } + + close(fd); + close(sockfd); + + return(retval); +} + +int sync_receive(int port, const char *file) { + rsaref_MD4_CTX mdctx; + unsigned char md4buf[16], check_md4buf[16]; + uint64_t filesize, filesize_s; + uint32_t blocksize; + uint32_t blockok_size, blockidx = 0; + uint8_t *blockok, blockok_val; + ssize_t cur_read_ret, read_ret, write_ret; + size_t bytestowrite; + off_t lseek_ret; + off_t curpos, destpos; + char *buf; + int sockfd, master_sockfd; + int retval = 0; + int fd; + int skipbytes; + int i = 0; + + fd = open(file, O_RDWR | O_CREAT | O_LARGEFILE, 0600); + if (fd < 0) { + CHECKPOINT; + return(-1); + } + + master_sockfd = net_listen(port); + if (master_sockfd < 0) { + close(fd); + CHECKPOINT; + return(-1); + } + + sockfd = accept(master_sockfd, NULL, 0); + if (sockfd < 0) { + close(fd); + close(master_sockfd); + CHECKPOINT; + return(-1); + } + + read_ret = read_large_net(sockfd, &filesize, sizeof(filesize)); + if (read_ret != sizeof(filesize)) { + close(fd); + close(sockfd); + close(master_sockfd); + CHECKPOINT; + return(-1); + } + + read_ret = read_large_net(sockfd, &blocksize, sizeof(blocksize)); + if (read_ret != sizeof(blocksize)) { + close(fd); + close(sockfd); + close(master_sockfd); + CHECKPOINT; + return(-1); + } + + filesize_s = filesize = ntohll(filesize); + blocksize = ntohl(blocksize); + + blockok_size = filesize / (8 * blocksize); + if ((filesize % (8 * blocksize)) != 0) { + blockok_size++; + } + + blockok = malloc(blockok_size); + if (!blockok) { + close(fd); + close(sockfd); + close(master_sockfd); + CHECKPOINT; + return(-1); + } + + buf = calloc(blocksize, 1); + if (!buf) { + close(fd); + close(sockfd); + close(master_sockfd); + CHECKPOINT; + return(-1); + } + + while (filesize) { + cur_read_ret = read_ret = read_large(fd, buf, blocksize); + if (read_ret < 0) { + retval = -1; + CHECKPOINT; + break; + } + + bytestowrite = blocksize; + if (bytestowrite > filesize) { + bytestowrite = filesize; + } + + if (read_ret != blocksize) { + memset(buf, '\0', bytestowrite); + read_ret = bytestowrite; + skipbytes = bytestowrite; + } else { + skipbytes = 0; + } + + rsaref_MD4Init(&mdctx); + rsaref_MD4Update(&mdctx, buf, read_ret); + rsaref_MD4Final(md4buf, &mdctx); + + read_ret = read_large_net(sockfd, check_md4buf, sizeof(check_md4buf)); + if (read_ret != sizeof(check_md4buf)) { + retval = -1; + CHECKPOINT; + break; + } + + if (memcmp(check_md4buf, md4buf, sizeof(md4buf)) == 0) { + blockok_val = 1; + } else { + blockok_val = 0; + } + + if (i == 0 || i == 8) { + if (i == 8) { + blockidx++; + } + i = 0; + blockok[blockidx] = 0; + } + blockok[blockidx] |= (blockok_val<= filesize_s) { + SPOTVAR_LLU(lseek_ret); + SPOTVAR_LLU(filesize_s); + SPOTVAR_I(i); + continue; + } + + read_ret = read_large_net(sockfd, buf, blocksize); + if (read_ret != blocksize) { + if ((lseek_ret + read_ret) != filesize_s || read_ret < 0) { + SPOTVAR_I(blockidx); + SPOTVAR_LLU(lseek_ret); + SPOTVAR_LLU(read_ret); + SPOTVAR_LLU(filesize_s); + retval = -1; + CHECKPOINT; + break; + } + } + + write_ret = write_large(fd, buf, read_ret); + if (write_ret != read_ret) { + retval = -1; + CHECKPOINT; + break; + } + + curpos += write_ret; + } + } + if (retval == -1) { + break; + } + } + } + + close(fd); + close(sockfd); + close(master_sockfd); + + return(retval); +} + +int main(int argc, char **argv) { + char *mode, *host, *port_str, *file, *blocksize_str; + uint32_t blocksize; + int func_ret; + int retval = EXIT_SUCCESS; + int port; + + if (argc < 2) { + return(print_help(EXIT_FAILURE)); + } + +#ifdef HAVE_SIGNAL +#ifdef SIGPIPE + signal(SIGPIPE, SIG_IGN); +#endif +#endif + + mode = argv[1]; + if (strcmp(mode, "-t") == 0) { + if (argc < 5 || argc > 6) { + return(print_help(EXIT_FAILURE)); + } + + host = argv[2]; + port_str = argv[3]; + file = argv[4]; + if (argc == 6) { + blocksize_str = argv[5]; + blocksize = strtoul(blocksize_str, NULL, 0); + } else { + blocksize = 256 * 1024; + } + + port = strtoul(port_str, NULL, 10); + + func_ret = sync_transmit(host, port, file, blocksize); + if (func_ret < 0) { + fprintf(stderr, "Failed.\n"); + retval = 1; + } + } else if (strcmp(mode, "-r") == 0) { + if (argc != 4) { + return(print_help(EXIT_FAILURE)); + } + + port_str = argv[2]; + file = argv[3]; + + port = strtoul(port_str, NULL, 10); + + func_ret = sync_receive(port, file); + if (func_ret < 0) { + fprintf(stderr, "Failed.\n"); + retval = 1; + } + } else { + return(print_help(EXIT_FAILURE)); + } + + printf("Bytes In: %llu, Bytes Out: %llu\n", net_bytesin, net_bytesout); + + return(retval); +} diff --git a/tools/notify-server b/tools/notify-server new file mode 100755 index 0000000..de867f8 --- /dev/null +++ b/tools/notify-server @@ -0,0 +1,189 @@ +#! /usr/bin/tclsh + +set BackupPCdNotifyServerPort 899 +set Hostfile "/etc/hosts" + +proc handle_connection {sock addr port} { + fileevent $sock readable [list handle_data $sock $addr $port] + + return +} + +proc handle_data {sock addr port} { + if {[eof $sock]} { + close $sock + return + } + + gets $sock line + set work [split [string trim $line]] + set cmd [string toupper [lindex $line 0]] + set arg [join [lrange $line 1 end]] + + switch -- $cmd { + "HOST" { + update_host_record $arg $addr + close $sock + } + } + + return +} + +proc update_host_record {host addr} { + set host [string tolower [lindex [split [string trim $host] .] 0]] + + set tmpfile "/tmp/notifyserv-[pid][clock seconds][expr abs([clock clicks])].tmp" + set bakfile "$::Hostfile.bak" + + set hostsfmtstr {%-23s %s} + + if {$host == ""} { + return + } + + catch { + set fd [open $::Hostfile "r"] + } + if {![info exists fd]} { + return + } + + catch { + set ofd [open $tmpfile "w"] + } + if {![info exists ofd]} { + close $fd + return + } + + set HostChanged 0 + set FoundHost 0 + while 1 { + gets $fd line + if {[eof $fd]} { + break + } + + set work [split [string trim [regsub {#.*$} $line {}]] " \t"] + if {[llength $work] == 0} { + puts $ofd $line + continue + } + + set hf_addr [lindex $work 0] + set hf_hosts [list] + foreach hf_host [lrange $work 1 end] { + set hf_host [string trim $hf_host] + if {$hf_host == ""} { + continue + } + + lappend hf_hosts $hf_host + } + + if {$hf_addr == $addr} { + foreach chk_host $hf_hosts { + if {[string tolower $chk_host] == [string tolower $host]} { + set FoundHost 1 + break + } + } + if {!$FoundHost} { + set line [format $hostsfmtstr $addr $host] + set HostChanged 1 + } + } else { + set new_hf_hosts [list] + foreach chk_host $hf_hosts { + if {[string tolower $chk_host] == [string tolower $host]} { + continue + } + lappend new_hf_hosts $chk_host + } + + if {$new_hf_hosts != $hf_hosts} { + if {[llength $new_hf_hosts] == 0} { + continue + } + + set line [format $hostsfmtstr $addr [join $new_hf_hosts]] + set HostChanged 1 + } + } + + puts $ofd $line + } + + if {!$FoundHost} { + if {!$HostChanged} { + puts $ofd [format $hostsfmtstr $addr $host] + } + } + + close $fd + close $ofd + + if {$FoundHost} { + catch { + file delete -force -- $tmpfile + } + + return + } + + catch { + set hf_attrs [file attributes $::Hostfile] + } + catch { + file delete -force -- $bakfile + } + + if {[catch { + file rename -force -- $::Hostfile $bakfile + file rename -force -- $tmpfile $::Hostfile + + if {[info exists hf_attrs]} { + eval [list file attributes $::Hostfile] $hf_attrs + } + }]} { + catch { + file delete -force -- $tmpfile + } + } + + return +} + +for {set i 0} {$i < 10} {incr i} { + if {![catch { + set servfd [socket -server handle_connection $BackupPCdNotifyServerPort] + } err]} { + break + } + + after 1000 +} + +if {![info exists servfd]} { + puts $err + exit 1 +} + +if {[catch { + package require Tclx +}]} { + puts stderr "Error loading the \"Tclx\" package, we cannot become a daemon." + puts stderr "Running in the foreground." + puts stderr "$errorInfo" + + vwait forever +} else { + # Become a daemon + if {[fork] == 0} { + if {[fork] == 0} { + cd / + vwait forever + } + } +} diff --git a/win32.h b/win32.h new file mode 100644 index 0000000..ed04e75 --- /dev/null +++ b/win32.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2005 Roy Keene + * + * 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. + * + * Author Information + * Roy Keene + * Planning Systems Inc + * Slidell, LA + * backuppcd-bugs@psislidell.com + */ + +#if !defined(_LOCAL_WIN32_H) && defined(__WIN32__) && !defined(__CYGWIN__) +#define _LOCAL_WIN32_H + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef __MINGW32__ +# ifdef NO_WIN32_NT4 +# define _WIN32_WINNT 0x0500 +# endif + /* MingW32 specific stuff here. */ +# if defined(HAVE_WINSOCK2_H) && defined(HAVE_LIBWSOCK32) + /* We have to override the detected configuration + because it can't detect the network libraries. */ +# define HAVE_GETHOSTBYNAME 1 +# define HAVE_INET_ADDR 1 +# define HAVE_SOCKET 1 +# define HAVE_CONNECT 1 +# define HAVE_GETHOSTNAME 1 +# endif +# define sleep(x) Sleep((x) * 1000) +#else + /* MSVC++ configuration follows (untested) */ +# undef HAVE_UNISTD_H +# define HAVE_STDLIB_H 1 +# define HAVE_WINDOWS_H 1 +# define HAVE_STDARG_H 1 +# define HAVE_WINSVC_H 1 +# define HAVE_WINSOCK2_H 1 +# define HAVE_WINDOWSX_H 1 +#endif /* __MINGW32__ */ + +#ifdef HAVE_WINDOWS_H +# include +#endif +#ifdef HAVE_WINDOWSX_H +# include +#endif +#ifdef HAVE_WINSOCK2_H +# include +#endif +#ifdef HAVE_WINSVC_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif + +#define MKDIR_TAKES_ONE_ARG 1 + +#define _USE_WIN32_ 1 + +#endif /* _LOCAL_WIN32_H */ -- 2.39.5