fakeroot-ng-0.18/0000755000175000017500000000000012131751667012063 5ustar sunsunfakeroot-ng-0.18/COPYING0000644000175000017500000004312210736005437013114 0ustar sunsun GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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. GNU GENERAL PUBLIC LICENSE 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 How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. fakeroot-ng-0.18/process.h0000644000175000017500000000056711210236620013702 0ustar sunsun#ifndef PROCESS_H #define PROCESS_H // Bitmasks to be stored in context_state[0] by all functions handling new process creation #define NEW_PROCESS_SAME_PARENT 0x01 #define NEW_PROCESS_SAME_VM 0x02 #define NEW_PROCESS_SAME_FD 0x04 #define NEW_PROCESS_SAME_ROOT 0x08 #define NEW_PROCESS_SAME_DEBUGGER 0x10 #endif // PROCESS_H fakeroot-ng-0.18/credentials.cpp0000644000175000017500000004673611461300537015073 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include "syscalls.h" #include "arch/platform.h" bool sys_getuid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; break; case pid_state::RETURN: ptlib_set_retval( pid, state->uid ); state->state=pid_state::NONE; break; } return true; } bool sys_geteuid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; break; case pid_state::RETURN: ptlib_set_retval( pid, state->euid ); state->state=pid_state::NONE; break; } return true; } bool sys_getgid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; break; case pid_state::RETURN: ptlib_set_retval( pid, state->gid ); state->state=pid_state::NONE; break; } return true; } bool sys_getegid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; break; case pid_state::RETURN: ptlib_set_retval( pid, state->egid ); state->state=pid_state::NONE; break; } return true; } #ifdef SYS_getresuid bool sys_getresuid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; // Do not trust the syscall not to change the pointers state->context_state[0]=ptlib_get_argument( pid, 1 ); state->context_state[1]=ptlib_get_argument( pid, 2 ); state->context_state[2]=ptlib_get_argument( pid, 3 ); break; case pid_state::RETURN: if( ptlib_success(pid, sc_num) ) { bool success; success=ptlib_set_mem( pid, &state->uid, state->context_state[0], sizeof(state->uid) ); success=success && ptlib_set_mem( pid, &state->euid, state->context_state[1], sizeof(state->euid) ); success=success && ptlib_set_mem( pid, &state->suid, state->context_state[2], sizeof(state->suid) ); if( !success ) { ptlib_set_error( pid, state->orig_sc, errno ); } } state->state=pid_state::NONE; break; } return true; } #endif #ifdef SYS_getresgid bool sys_getresgid( int sc_num, pid_t pid, pid_state *state ) { switch( state->state ) { default: case pid_state::NONE: state->state=pid_state::RETURN; // Do not trust the syscall not to change the pointers state->context_state[0]=ptlib_get_argument( pid, 1 ); state->context_state[1]=ptlib_get_argument( pid, 2 ); state->context_state[2]=ptlib_get_argument( pid, 3 ); break; case pid_state::RETURN: if( ptlib_success(pid, sc_num) ) { bool success; success=ptlib_set_mem( pid, &state->gid, state->context_state[0], sizeof(state->gid) ); success=success && ptlib_set_mem( pid, &state->egid, state->context_state[1], sizeof(state->egid) ); success=success && ptlib_set_mem( pid, &state->sgid, state->context_state[2], sizeof(state->sgid) ); if( !success ) { ptlib_set_error( pid, state->orig_sc, errno ); } } state->state=pid_state::NONE; break; } return true; } #endif bool sys_getgroups( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { ptlib_set_syscall(pid, PREF_NOP); state->state=pid_state::REDIRECT2; // Store the arguments for later state->context_state[0]=ptlib_get_argument( pid, 1 ); state->context_state[1]=ptlib_get_argument( pid, 2 ); } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; // What is the size? if( state->context_state[0]==0 ) { // Merely report the number of groups we have ptlib_set_retval( pid, state->groups.size() ); } else if( state->context_state[0]groups.size() ) { // Not enough room ptlib_set_error( pid, state->orig_sc, EINVAL ); } else { unsigned int count=0; gid_t *groups=(gid_t *)state->context_state[1]; bool success=true; for( std::set::const_iterator i=state->groups.begin(); success && i!=state->groups.end(); ++i, ++count ) { success=ptlib_set_mem( pid, &*i, (int_ptr)(groups+count), sizeof(gid_t) ); } if( success ) ptlib_set_retval( pid, count ); else ptlib_set_error( pid, state->orig_sc, errno ); } } return true; } bool sys_setuid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action uid_t uid=(uid_t)state->context_state[0]; if( state->euid==ROOT_UID ) { // Super user version state->uid=state->euid=state->suid=state->fsuid=uid; ptlib_set_retval( pid, 0 ); } else if( state->uid==uid || state->suid==uid ) { // Regular user, but with an operation that is ok state->euid=state->fsuid=uid; ptlib_set_retval (pid, 0 ); } else { // No permission ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } static bool check_uids( uid_t new_uid, const pid_state *state ) { return state->euid==ROOT_UID || new_uid==state->uid || new_uid==state->euid || new_uid==state->suid; } bool sys_seteuid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action uid_t uid=(uid_t)state->context_state[0]; if( check_uids( uid, state ) ) { state->euid=state->fsuid=uid; ptlib_set_retval( pid, 0 ); } else { // No permission ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } bool sys_setfsuid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action uid_t uid=(uid_t)state->context_state[0]; uid_t old_fsuid=state->fsuid; if( check_uids( uid, state ) ) { state->fsuid=uid; } else { // No permission - nothing to do } ptlib_set_retval( pid, old_fsuid ); state->state=pid_state::NONE; } return true; } bool sys_setresuid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); //ruid state->context_state[1]=ptlib_get_argument( pid, 2 ); //euid state->context_state[2]=ptlib_get_argument( pid, 3 ); //suid // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action bool success=true; uid_t new_uid=state->uid, new_euid=state->euid, new_suid=state->suid; if( state->context_state[0]!=(int_ptr)-1 ) { if( check_uids( state->context_state[0], state ) ) new_uid=state->context_state[0]; else success=false; } if( state->context_state[1]!=(int_ptr)-1 ) { if( success && check_uids( state->context_state[1], state ) ) new_euid=state->context_state[1]; else success=false; } if( state->context_state[2]!=(int_ptr)-1 ) { if( success && check_uids( state->context_state[2], state ) ) new_suid=state->context_state[2]; else success=false; } // If all checks passed, commit the changes if( success ) { state->uid=new_uid; state->euid=new_euid; state->suid=new_suid; ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } bool sys_setreuid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); //ruid state->context_state[1]=ptlib_get_argument( pid, 2 ); //euid // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action bool success=true; uid_t new_uid=state->uid, new_euid=state->euid, new_suid=state->suid; if( state->context_state[0]!=(int_ptr)-1 ) { // XXX Linux specific behavior if( state->euid==ROOT_UID || state->context_state[0]==state->uid || state->context_state[0]==state->suid ) new_uid=state->context_state[0]; else success=false; } if( state->context_state[1]!=(int_ptr)-1 ) { if( success && check_uids( state->context_state[1], state ) ) new_euid=state->context_state[1]; else success=false; } // There is no POSIX documentation on what should happen to the saved UID. The following is the Linux logic if( success && (state->context_state[0]!=(int_ptr)-1 || ( state->context_state[1]!=(int_ptr)-1 && state->context_state[1]!=state->uid )) ) { new_suid=new_euid; } // If all checks passed, commit the changes if( success ) { state->uid=new_uid; state->euid=state->fsuid=new_euid; state->suid=new_suid; ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } bool sys_setgroups( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { ptlib_set_syscall(pid, PREF_NOP); state->state=pid_state::REDIRECT2; // Store the arguments for later state->context_state[0]=ptlib_get_argument( pid, 1 ); state->context_state[1]=ptlib_get_argument( pid, 2 ); } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; std::set new_groups; gid_t *process_groups=(gid_t *)state->context_state[1]; int error=0; while( error==0 && state->context_state[0]>0 ) { gid_t group; if( ptlib_get_mem( pid, (int_ptr)process_groups++, &group, sizeof(gid_t) ) ) { new_groups.insert(group); --state->context_state[0]; } else { error=errno; } } if( error==0 ) { state->groups=new_groups; ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, error ); } } return true; } bool sys_setgid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action gid_t gid=(gid_t)state->context_state[0]; if( state->egid==ROOT_UID ) { // Super user version state->gid=state->egid=state->sgid=state->fsgid=gid; ptlib_set_retval( pid, 0 ); } else if( state->gid==gid || state->sgid==gid ) { // Regular user, but with an operation that is ok state->egid=state->fsgid=gid; ptlib_set_retval (pid, 0 ); } else { // No permission ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } static bool check_gids( gid_t new_gid, const pid_state *state ) { return state->egid==ROOT_GID || new_gid==state->gid || new_gid==state->egid || new_gid==state->sgid; } bool sys_setegid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Save the original arguments state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action gid_t gid=(gid_t)state->context_state[0]; if( check_gids( gid, state ) ) { state->egid=state->fsgid=gid; ptlib_set_retval( pid, 0 ); } else { // No permission ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } bool sys_setfsgid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action gid_t gid=(gid_t)state->context_state[0]; gid_t old_fsgid=state->fsgid; if( check_gids( gid, state ) ) { state->fsgid=gid; } else { // No permission - nothing to do } ptlib_set_retval( pid, old_fsgid ); state->state=pid_state::NONE; } return true; } bool sys_setresgid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); //rgid state->context_state[1]=ptlib_get_argument( pid, 2 ); //egid state->context_state[2]=ptlib_get_argument( pid, 3 ); //sgid // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action bool success=true; gid_t new_gid=state->gid, new_egid=state->egid, new_sgid=state->sgid; if( state->context_state[0]!=(int_ptr)-1 ) { if( check_gids( state->context_state[0], state ) ) new_gid=state->context_state[0]; else success=false; } if( state->context_state[1]!=(int_ptr)-1 ) { if( success && check_gids( state->context_state[1], state ) ) new_egid=state->context_state[1]; else success=false; } if( state->context_state[2]!=(int_ptr)-1 ) { if( success && check_gids( state->context_state[2], state ) ) new_sgid=state->context_state[2]; else success=false; } // If all checks passed, commit the changes if( success ) { state->gid=new_gid; state->egid=new_egid; state->sgid=new_sgid; ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } bool sys_setregid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Do we let the syscall proceed? state->context_state[0]=ptlib_get_argument( pid, 1 ); //rgid state->context_state[1]=ptlib_get_argument( pid, 2 ); //egid // NOP the actual call ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { // Let's see if we want to perform the action bool success=true; gid_t new_gid=state->gid, new_egid=state->egid, new_sgid=state->sgid; if( state->context_state[0]!=(int_ptr)-1 ) { // XXX Linux specific behavior if( state->egid==ROOT_GID || state->context_state[0]==state->gid || state->context_state[0]==state->sgid ) new_gid=state->context_state[0]; else success=false; } if( state->context_state[1]!=(int_ptr)-1 ) { if( success && check_gids( state->context_state[1], state ) ) new_egid=state->context_state[1]; else success=false; } // There is no POSIX documentation on what should happen to the saved UID. The following is the Linux logic if( success && (state->context_state[0]!=(int_ptr)-1 || ( state->context_state[1]!=(int_ptr)-1 && state->context_state[1]!=state->gid )) ) { new_sgid=new_egid; } // If all checks passed, commit the changes if( success ) { state->gid=new_gid; state->egid=state->fsgid=new_egid; state->sgid=new_sgid; ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, EPERM ); } state->state=pid_state::NONE; } return true; } fakeroot-ng-0.18/AUTHORS0000644000175000017500000000521712123336737013136 0ustar sunsunfakeroot-ng is copyright (c) 2007-2009,2013 by Shachar Shemesh Project's home page is at http://fakeroot-ng.lingnu.com Special thanks goes to Bernhard R. Link for insisting that things be better than "good enough". Thanks should also go to Tyler Larson, for saying "I need this fixed, so I'll pay for your time". The true open source model at work. 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Contact Shachar at shachar@debian.org. Commercial support is available through Shachar's company, Lingnu Open Source Consulting Ltd. http://www.lingnu.com If I have seen further it is by standing on the shoulders of Giants. Sir Izik Newton Himself quoting the great men of the renaissance Fakeroot Next Generation was written by Shachar Shemesh, in his spare time (such that there is). Fakeroot NextGen is a clean reimplementation, and no code was taken from previous implementations. It is based on a completely different technology, and therefor does not suffer from the other implementations limitations (but probably has its own unique ones). The idea behind fakeroot ng has been around long before it came around. The first implementation, as far as we could find, is called "fakeroot". It can be found at http://alioth.debian.org/projects/fakeroot/. It lists Joost Witteveen, Clint Adams and Timo Savola as the authors. Its functionality, as well as its limitations, have been the inspiration that brought fakeroot-ng to be. The original fakeroot's limitations were also the trigger that brought another project about. Called "fakechroot", written by Piotr Roszatycki, home dir at http://fakechroot.alioth.debian.org/, it attempts to overcome one of fakeroot's main limitation - its inability to catch the open(2) system call, and therefor its inability to emulate the "chroot" environment. It does not, however, change the core technology used, and therefor has limitations over how complete the environment is. It is hoped that as fakeroot-ng progresses, we can eliminate all of the limitations. fakeroot-ng-0.18/chroot.h0000644000175000017500000000362511461300537013527 0ustar sunsun#ifndef CHROOT_H #define CHROOT_H #include #ifndef _FCNTL_H #include #endif struct pid_state; bool chroot_is_chrooted( const pid_state *state ); // translate a process relative path into a path that is correct outside of the process // "path" must be in a writable buffer, and its content will be scratch by the function // "wd" is the directory in relation to which relative paths should be interpreted // "stat" is going to be filled in with the detail of the last element of the path returned // If there is some error (say - file not found) stat->st_ino will be equal -1 and errno // will be set // If there was no error, but no stat was necessary, stat->st_ino will be equal -2 std::string chroot_parse_path( const pid_state *state, char *path, const std::string &wd, struct stat *stat, bool resolve_last_link ); // Same as above, only grab the work directory and file name from the process' state std::string chroot_translate_addr( pid_t pid, const pid_state *state, struct stat *stat, int dirfd, int_ptr addr, bool resolve_last_link ); // If dirfd is CHROOT_PWD, everything is relative to the current work dir for the process // Grab the original path from the process space, translate the path (if chrooted) write the // new path into the shared memory and move the original param to point at the new path. // param_num - the param number to translate // abort_error - if true and an error occures, do not copy the partial string // offset - offset into the shared memory to write buffer to bool chroot_translate_param( pid_t pid, const pid_state *state, int param_num, bool resolve_last_link, bool abort_error=false, int_ptr offset=0 ); bool chroot_translate_paramat( pid_t pid, const pid_state *state, int dirfd, int param_num, bool resolve_last_link, bool abort_error=false, int_ptr offset=0 ); #ifdef AT_FDCWD #define CHROOT_PWD AT_FDCWD #else #define CHROOT_PWD (-1) #endif #endif // CHROOT_H fakeroot-ng-0.18/aclocal.m40000644000175000017500000010346312131751663013726 0ustar sunsun# generated automatically by aclocal 1.11.1 -*- Autoconf -*- # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, # 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.67],, [m4_warning([this file was generated for autoconf 2.67. You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically `autoreconf'.])]) # Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_AUTOMAKE_VERSION(VERSION) # ---------------------------- # Automake X.Y traces this macro to ensure aclocal.m4 has been # generated from the m4 files accompanying Automake X.Y. # (This private macro should not be called outside this file.) AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version='1.11' dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to dnl require some minimum version. Point them to the right macro. m4_if([$1], [1.11.1], [], [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl ]) # _AM_AUTOCONF_VERSION(VERSION) # ----------------------------- # aclocal traces this macro to find the Autoconf version. # This is a private macro too. Using m4_define simplifies # the logic in aclocal, which can simply ignore this definition. m4_define([_AM_AUTOCONF_VERSION], []) # AM_SET_CURRENT_AUTOMAKE_VERSION # ------------------------------- # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. # This function is AC_REQUIREd by AM_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], [AM_AUTOMAKE_VERSION([1.11.1])dnl m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- # Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets # $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to # `$srcdir', `$srcdir/..', or `$srcdir/../..'. # # Of course, Automake must honor this variable whenever it calls a # tool from the auxiliary directory. The problem is that $srcdir (and # therefore $ac_aux_dir as well) can be either absolute or relative, # depending on how configure is run. This is pretty annoying, since # it makes $ac_aux_dir quite unusable in subdirectories: in the top # source directory, any form will work fine, but in subdirectories a # relative path needs to be adjusted first. # # $ac_aux_dir/missing # fails when called from a subdirectory if $ac_aux_dir is relative # $top_srcdir/$ac_aux_dir/missing # fails if $ac_aux_dir is absolute, # fails when called from a subdirectory in a VPATH build with # a relative $ac_aux_dir # # The reason of the latter failure is that $top_srcdir and $ac_aux_dir # are both prefixed by $srcdir. In an in-source build this is usually # harmless because $srcdir is `.', but things will broke when you # start a VPATH build or use an absolute $srcdir. # # So we could use something similar to $top_srcdir/$ac_aux_dir/missing, # iff we strip the leading $srcdir from $ac_aux_dir. That would be: # am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` # and then we would define $MISSING as # MISSING="\${SHELL} $am_aux_dir/missing" # This will work as long as MISSING is not called from configure, because # unfortunately $(top_srcdir) has no meaning in configure. # However there are other variables, like CC, which are often used in # configure, and could therefore not use this "fixed" $ac_aux_dir. # # Another solution, used here, is to always expand $ac_aux_dir to an # absolute PATH. The drawback is that using absolute paths prevent a # configured tree to be moved without reconfiguration. AC_DEFUN([AM_AUX_DIR_EXPAND], [dnl Rely on autoconf to set up CDPATH properly. AC_PREREQ([2.50])dnl # expand $ac_aux_dir to an absolute path am_aux_dir=`cd $ac_aux_dir && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006, 2008 # Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 9 # AM_CONDITIONAL(NAME, SHELL-CONDITION) # ------------------------------------- # Define a conditional. AC_DEFUN([AM_CONDITIONAL], [AC_PREREQ(2.52)dnl ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl AC_SUBST([$1_TRUE])dnl AC_SUBST([$1_FALSE])dnl _AM_SUBST_NOTMAKE([$1_TRUE])dnl _AM_SUBST_NOTMAKE([$1_FALSE])dnl m4_define([_AM_COND_VALUE_$1], [$2])dnl if $2; then $1_TRUE= $1_FALSE='#' else $1_TRUE='#' $1_FALSE= fi AC_CONFIG_COMMANDS_PRE( [if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then AC_MSG_ERROR([[conditional "$1" was never defined. Usually this means the macro was only invoked conditionally.]]) fi])]) # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2009 # Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 10 # There are a few dirty hacks below to avoid letting `AC_PROG_CC' be # written in clear, in which case automake, when reading aclocal.m4, # will think it sees a *use*, and therefore will trigger all it's # C support machinery. Also note that it means that autoscan, seeing # CC etc. in the Makefile, will ask for an AC_PROG_CC use... # _AM_DEPENDENCIES(NAME) # ---------------------- # See how the compiler implements dependency checking. # NAME is "CC", "CXX", "GCJ", or "OBJC". # We try a few techniques and use that to set a single cache variable. # # We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was # modified to invoke _AM_DEPENDENCIES(CC); we would have a circular # dependency, and given that the user is not expected to run this macro, # just rely on AC_PROG_CC. AC_DEFUN([_AM_DEPENDENCIES], [AC_REQUIRE([AM_SET_DEPDIR])dnl AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl AC_REQUIRE([AM_MAKE_INCLUDE])dnl AC_REQUIRE([AM_DEP_TRACK])dnl ifelse([$1], CC, [depcc="$CC" am_compiler_list=], [$1], CXX, [depcc="$CXX" am_compiler_list=], [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'], [$1], UPC, [depcc="$UPC" am_compiler_list=], [$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'], [depcc="$$1" am_compiler_list=]) AC_CACHE_CHECK([dependency style of $depcc], [am_cv_$1_dependencies_compiler_type], [if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named `D' -- because `-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_$1_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` fi am__universal=false m4_case([$1], [CC], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac], [CXX], [case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac]) for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with # Solaris 8's {/usr,}/bin/sh. touch sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with `-c' and `-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle `-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # after this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvisualcpp | msvcmsys) # This compiler won't grok `-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_$1_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_$1_dependencies_compiler_type=none fi ]) AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) AM_CONDITIONAL([am__fastdep$1], [ test "x$enable_dependency_tracking" != xno \ && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) ]) # AM_SET_DEPDIR # ------------- # Choose a directory name for dependency files. # This macro is AC_REQUIREd in _AM_DEPENDENCIES AC_DEFUN([AM_SET_DEPDIR], [AC_REQUIRE([AM_SET_LEADING_DOT])dnl AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl ]) # AM_DEP_TRACK # ------------ AC_DEFUN([AM_DEP_TRACK], [AC_ARG_ENABLE(dependency-tracking, [ --disable-dependency-tracking speeds up one-time build --enable-dependency-tracking do not reject slow dependency extractors]) if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' fi AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) AC_SUBST([AMDEPBACKSLASH])dnl _AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl ]) # Generate code to set up dependency tracking. -*- Autoconf -*- # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2008 # Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. #serial 5 # _AM_OUTPUT_DEPENDENCY_COMMANDS # ------------------------------ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ # Autoconf 2.62 quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named `Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`AS_DIRNAME("$mf")` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running `make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # When using ansi2knr, U may be empty or an underscore; expand it U=`sed -n 's/^U = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`AS_DIRNAME(["$file"])` AS_MKDIR_P([$dirpart/$fdir]) # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ])# _AM_OUTPUT_DEPENDENCY_COMMANDS # AM_OUTPUT_DEPENDENCY_COMMANDS # ----------------------------- # This macro should only be invoked once -- use via AC_REQUIRE. # # This code is only required when automatic dependency tracking # is enabled. FIXME. This creates each `.P' file that we will # need in order to bootstrap the dependency handling code. AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], [AC_CONFIG_COMMANDS([depfiles], [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) ]) # Do all the work for Automake. -*- Autoconf -*- # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, # 2005, 2006, 2008, 2009 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 16 # This macro actually does too much. Some checks are only needed if # your package does certain things. But this isn't really a big deal. # AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) # AM_INIT_AUTOMAKE([OPTIONS]) # ----------------------------------------------- # The call with PACKAGE and VERSION arguments is the old style # call (pre autoconf-2.50), which is being phased out. PACKAGE # and VERSION should now be passed to AC_INIT and removed from # the call to AM_INIT_AUTOMAKE. # We support both call styles for the transition. After # the next Automake release, Autoconf can make the AC_INIT # arguments mandatory, and then we can depend on a new Autoconf # release and drop the old call support. AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.62])dnl dnl Autoconf wants to disallow AM_ names. We explicitly allow dnl the ones we care about. m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl # test to see if srcdir already configured if test -f $srcdir/config.status; then AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi AC_SUBST([CYGPATH_W]) # Define the identity of the package. dnl Distinguish between old-style and new-style calls. m4_ifval([$2], [m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl AC_SUBST([PACKAGE], [$1])dnl AC_SUBST([VERSION], [$2])], [_AM_SET_OPTIONS([$1])dnl dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,, [m4_fatal([AC_INIT should be called with package and version arguments])])dnl AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl _AM_IF_OPTION([no-define],, [AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package]) AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl # Some tools Automake needs. AC_REQUIRE([AM_SANITY_CHECK])dnl AC_REQUIRE([AC_ARG_PROGRAM])dnl AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version}) AM_MISSING_PROG(AUTOCONF, autoconf) AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version}) AM_MISSING_PROG(AUTOHEADER, autoheader) AM_MISSING_PROG(MAKEINFO, makeinfo) AC_REQUIRE([AM_PROG_INSTALL_SH])dnl AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl AC_REQUIRE([AM_PROG_MKDIR_P])dnl # We need awk for the "check" target. The system "awk" is bad on # some platforms. AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([AC_PROG_MAKE_SET])dnl AC_REQUIRE([AM_SET_LEADING_DOT])dnl _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], [_AM_PROG_TAR([v7])])]) _AM_IF_OPTION([no-dependencies],, [AC_PROVIDE_IFELSE([AC_PROG_CC], [_AM_DEPENDENCIES(CC)], [define([AC_PROG_CC], defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl AC_PROVIDE_IFELSE([AC_PROG_CXX], [_AM_DEPENDENCIES(CXX)], [define([AC_PROG_CXX], defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl AC_PROVIDE_IFELSE([AC_PROG_OBJC], [_AM_DEPENDENCIES(OBJC)], [define([AC_PROG_OBJC], defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl ]) _AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl dnl The `parallel-tests' driver may need to know about EXEEXT, so add the dnl `am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro dnl is hooked onto _AC_COMPILER_EXEEXT early, see below. AC_CONFIG_COMMANDS_PRE(dnl [m4_provide_if([_AM_COMPILER_EXEEXT], [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl ]) dnl Hook into `_AC_COMPILER_EXEEXT' early to learn its expansion. Do not dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further dnl mangled by Autoconf and run in a shell conditional statement. m4_define([_AC_COMPILER_EXEEXT], m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) # When config.status generates a header, we must update the stamp-h file. # This file resides in the same directory as the config header # that is generated. The stamp files are numbered to have different names. # Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the # loop where config.status creates the headers, so we can generate # our stamp files there. AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], [# Compute $1's index in $config_headers. _am_arg=$1 _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) # Copyright (C) 2001, 2003, 2005, 2008 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_PROG_INSTALL_SH # ------------------ # Define $install_sh. AC_DEFUN([AM_PROG_INSTALL_SH], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl if test x"${install_sh}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi AC_SUBST(install_sh)]) # Copyright (C) 2003, 2005 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # Check whether the underlying file-system supports filenames # with a leading dot. For instance MS-DOS doesn't. AC_DEFUN([AM_SET_LEADING_DOT], [rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null AC_SUBST([am__leading_dot])]) # Check to see how 'make' treats includes. -*- Autoconf -*- # Copyright (C) 2001, 2002, 2003, 2005, 2009 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 4 # AM_MAKE_INCLUDE() # ----------------- # Check to see how make treats includes. AC_DEFUN([AM_MAKE_INCLUDE], [am_make=${MAKE-make} cat > confinc << 'END' am__doit: @echo this is the am__doit target .PHONY: am__doit END # If we don't find an include directive, just comment out the code. AC_MSG_CHECKING([for style of include used by $am_make]) am__include="#" am__quote= _am_result=none # First try GNU make style include. echo "include confinc" > confmf # Ignore all kinds of additional output from `make'. case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=include am__quote= _am_result=GNU ;; esac # Now try BSD make style include. if test "$am__include" = "#"; then echo '.include "confinc"' > confmf case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=.include am__quote="\"" _am_result=BSD ;; esac fi AC_SUBST([am__include]) AC_SUBST([am__quote]) AC_MSG_RESULT([$_am_result]) rm -f confinc confmf ]) # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- # Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005, 2008 # Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 6 # AM_MISSING_PROG(NAME, PROGRAM) # ------------------------------ AC_DEFUN([AM_MISSING_PROG], [AC_REQUIRE([AM_MISSING_HAS_RUN]) $1=${$1-"${am_missing_run}$2"} AC_SUBST($1)]) # AM_MISSING_HAS_RUN # ------------------ # Define MISSING if not defined so far and test if it supports --run. # If it does, set am_missing_run to use it, otherwise, to nothing. AC_DEFUN([AM_MISSING_HAS_RUN], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl AC_REQUIRE_AUX_FILE([missing])dnl if test x"${MISSING+set}" != xset; then case $am_aux_dir in *\ * | *\ *) MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; *) MISSING="\${SHELL} $am_aux_dir/missing" ;; esac fi # Use eval to expand $SHELL if eval "$MISSING --run true"; then am_missing_run="$MISSING --run " else am_missing_run= AC_MSG_WARN([`missing' script is too old or missing]) fi ]) # Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_PROG_MKDIR_P # --------------- # Check for `mkdir -p'. AC_DEFUN([AM_PROG_MKDIR_P], [AC_PREREQ([2.60])dnl AC_REQUIRE([AC_PROG_MKDIR_P])dnl dnl Automake 1.8 to 1.9.6 used to define mkdir_p. We now use MKDIR_P, dnl while keeping a definition of mkdir_p for backward compatibility. dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile. dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of dnl Makefile.ins that do not define MKDIR_P, so we do our own dnl adjustment using top_builddir (which is defined more often than dnl MKDIR_P). AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl case $mkdir_p in [[\\/$]]* | ?:[[\\/]]*) ;; */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;; esac ]) # Helper functions for option handling. -*- Autoconf -*- # Copyright (C) 2001, 2002, 2003, 2005, 2008 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 4 # _AM_MANGLE_OPTION(NAME) # ----------------------- AC_DEFUN([_AM_MANGLE_OPTION], [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) # _AM_SET_OPTION(NAME) # ------------------------------ # Set option NAME. Presently that only means defining a flag for this option. AC_DEFUN([_AM_SET_OPTION], [m4_define(_AM_MANGLE_OPTION([$1]), 1)]) # _AM_SET_OPTIONS(OPTIONS) # ---------------------------------- # OPTIONS is a space-separated list of Automake options. AC_DEFUN([_AM_SET_OPTIONS], [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) # _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) # ------------------------------------------- # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. AC_DEFUN([_AM_IF_OPTION], [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) # Check to make sure that the build environment is sane. -*- Autoconf -*- # Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005, 2008 # Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 5 # AM_SANITY_CHECK # --------------- AC_DEFUN([AM_SANITY_CHECK], [AC_MSG_CHECKING([whether build environment is sane]) # Just in case sleep 1 echo timestamp > conftest.file # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[[\\\"\#\$\&\'\`$am_lf]]*) AC_MSG_ERROR([unsafe absolute working directory name]);; esac case $srcdir in *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) AC_MSG_ERROR([unsafe srcdir value: `$srcdir']);; esac # Do `set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$[*]" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi rm -f conftest.file if test "$[*]" != "X $srcdir/configure conftest.file" \ && test "$[*]" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken alias in your environment]) fi test "$[2]" = conftest.file ) then # Ok. : else AC_MSG_ERROR([newly created file is older than distributed files! Check your system clock]) fi AC_MSG_RESULT(yes)]) # Copyright (C) 2001, 2003, 2005 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # AM_PROG_INSTALL_STRIP # --------------------- # One issue with vendor `install' (even GNU) is that you can't # specify the program used to strip binaries. This is especially # annoying in cross-compiling environments, where the build's strip # is unlikely to handle the host's binaries. # Fortunately install-sh will honor a STRIPPROG variable, so we # always use install-sh in `make install-strip', and initialize # STRIPPROG with the value of the STRIP variable (set by the user). AC_DEFUN([AM_PROG_INSTALL_STRIP], [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl # Installed binaries are usually stripped using `strip' when the user # run `make install-strip'. However `strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the `STRIP' environment variable to overrule this program. dnl Don't test for $cross_compiling = yes, because it might be `maybe'. if test "$cross_compiling" != no; then AC_CHECK_TOOL([STRIP], [strip], :) fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" AC_SUBST([INSTALL_STRIP_PROGRAM])]) # Copyright (C) 2006, 2008 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # _AM_SUBST_NOTMAKE(VARIABLE) # --------------------------- # Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. # This macro is traced by Automake. AC_DEFUN([_AM_SUBST_NOTMAKE]) # AM_SUBST_NOTMAKE(VARIABLE) # --------------------------- # Public sister of _AM_SUBST_NOTMAKE. AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) # Check how to create a tarball. -*- Autoconf -*- # Copyright (C) 2004, 2005 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # serial 2 # _AM_PROG_TAR(FORMAT) # -------------------- # Check how to create a tarball in format FORMAT. # FORMAT should be one of `v7', `ustar', or `pax'. # # Substitute a variable $(am__tar) that is a command # writing to stdout a FORMAT-tarball containing the directory # $tardir. # tardir=directory && $(am__tar) > result.tar # # Substitute a variable $(am__untar) that extract such # a tarball read from stdin. # $(am__untar) < result.tar AC_DEFUN([_AM_PROG_TAR], [# Always define AMTAR for backward compatibility. AM_MISSING_PROG([AMTAR], [tar]) m4_if([$1], [v7], [am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'], [m4_case([$1], [ustar],, [pax],, [m4_fatal([Unknown tar format])]) AC_MSG_CHECKING([how to create a $1 tar archive]) # Loop over all known methods to create a tar archive until one works. _am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' _am_tools=${am_cv_prog_tar_$1-$_am_tools} # Do not fold the above two line into one, because Tru64 sh and # Solaris sh will not grok spaces in the rhs of `-'. for _am_tool in $_am_tools do case $_am_tool in gnutar) for _am_tar in tar gnutar gtar; do AM_RUN_LOG([$_am_tar --version]) && break done am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' am__untar="$_am_tar -xf -" ;; plaintar) # Must skip GNU tar: if it does not support --format= it doesn't create # ustar tarball either. (tar --version) >/dev/null 2>&1 && continue am__tar='tar chf - "$$tardir"' am__tar_='tar chf - "$tardir"' am__untar='tar xf -' ;; pax) am__tar='pax -L -x $1 -w "$$tardir"' am__tar_='pax -L -x $1 -w "$tardir"' am__untar='pax -r' ;; cpio) am__tar='find "$$tardir" -print | cpio -o -H $1 -L' am__tar_='find "$tardir" -print | cpio -o -H $1 -L' am__untar='cpio -i -H $1 -d' ;; none) am__tar=false am__tar_=false am__untar=false ;; esac # If the value was cached, stop now. We just wanted to have am__tar # and am__untar set. test -n "${am_cv_prog_tar_$1}" && break # tar/untar a dummy directory, and stop if the command works rm -rf conftest.dir mkdir conftest.dir echo GrepMe > conftest.dir/file AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) rm -rf conftest.dir if test -s conftest.tar; then AM_RUN_LOG([$am__untar /dev/null 2>&1 && break fi done rm -rf conftest.dir AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) AC_MSG_RESULT([$am_cv_prog_tar_$1])]) AC_SUBST([am__tar]) AC_SUBST([am__untar]) ]) # _AM_PROG_TAR fakeroot-ng-0.18/file_lie.cpp0000644000175000017500000000511112076741772014341 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include "file_lie.h" struct db_key_hash { size_t operator()(const override_key &key) const { return key.inode; }; }; typedef std::unordered_map file_hash; static file_hash map_hash; bool get_map( dev_t dev, ptlib_inode_t inode, stat_override *stat ) { file_hash::iterator i(map_hash.find( override_key( dev, inode) )); if( i!=map_hash.end() ) { *stat=i->second; return true; } else { return false; } } void set_map( const stat_override *stat ) { map_hash[override_key(stat->dev, stat->inode)]=*stat; } void remove_map( dev_t dev, ptlib_inode_t inode ) { file_hash::iterator i(map_hash.find( override_key( dev, inode) )); if( i!=map_hash.end() ) map_hash.erase(i); } void load_map( FILE *file ) { stat_override override; int params; while( (params=fscanf(file, "dev=" DEV_F ", ino=" INODE_F ", mode=%o, uid=%d, gid=%d, rdev=" DEV_F " \n", &override.dev, &override.inode, &override.mode, &override.uid, &override.gid, &override.dev_id ))==6 ) { set_map( &override ); } } void save_map( FILE *file ) { for( file_hash::const_iterator i=map_hash.begin(); i!=map_hash.end() ; ++i ) { const struct stat_override *override; override=&(i->second); if( !override->transient ) { fprintf( file, "dev=" DEV_F ",ino=" INODE_F ",mode=%o,uid=%d,gid=%d,rdev=" DEV_F "\n", override->dev, override->inode, override->mode, override->uid, override->gid, override->dev_id ); } } } fakeroot-ng-0.18/INSTALL0000644000175000017500000003633212131751664013120 0ustar sunsunInstallation Instructions ************************* Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without warranty of any kind. Basic Installation ================== Briefly, the shell commands `./configure; make; make install' should configure, build, and install this package. The following more-detailed instructions are generic; see the `README' file for instructions specific to this package. Some packages provide this `INSTALL' file but do not implement all of the features documented below. The lack of an optional feature in a given package is not necessarily a bug. More recommendations for GNU packages can be found in *note Makefile Conventions: (standards)Makefile Conventions. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile' in each directory of the package. It may also create one or more `.h' files containing system-dependent definitions. Finally, it creates a shell script `config.status' that you can run in the future to recreate the current configuration, and a file `config.log' containing compiler output (useful mainly for debugging `configure'). It can also use an optional file (typically called `config.cache' and enabled with `--cache-file=config.cache' or simply `-C') that saves the results of its tests to speed up reconfiguring. Caching is disabled by default to prevent problems with accidental use of stale cache files. If you need to do unusual things to compile the package, please try to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the `README' so they can be considered for the next release. If you are using the cache, and at some point `config.cache' contains results you don't want to keep, you may remove or edit it. The file `configure.ac' (or `configure.in') is used to create `configure' by a program called `autoconf'. You need `configure.ac' if you want to change it or regenerate `configure' using a newer version of `autoconf'. The simplest way to compile this package is: 1. `cd' to the directory containing the package's source code and type `./configure' to configure the package for your system. Running `configure' might take a while. While running, it prints some messages telling which features it is checking for. 2. Type `make' to compile the package. 3. Optionally, type `make check' to run any self-tests that come with the package, generally using the just-built uninstalled binaries. 4. Type `make install' to install the programs and any data files and documentation. When installing into a prefix owned by root, it is recommended that the package be configured and built as a regular user, and only the `make install' phase executed with root privileges. 5. Optionally, type `make installcheck' to repeat any self-tests, but this time using the binaries in their final installed location. This target does not install anything. Running this target as a regular user, particularly if the prior `make install' required root privileges, verifies that the installation completed correctly. 6. You can remove the program binaries and object files from the source code directory by typing `make clean'. To also remove the files that `configure' created (so you can compile the package for a different kind of computer), type `make distclean'. There is also a `make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. 7. Often, you can also type `make uninstall' to remove the installed files again. In practice, not all packages have tested that uninstallation works correctly, even though it is required by the GNU Coding Standards. 8. Some packages, particularly those that use Automake, provide `make distcheck', which can by used by developers to test that all other targets like `make install' and `make uninstall' work correctly. This target is generally not run by end users. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the `configure' script does not know about. Run `./configure --help' for details on some of the pertinent environment variables. You can give `configure' initial values for configuration parameters by setting variables in the command line or in the environment. Here is an example: ./configure CC=c99 CFLAGS=-g LIBS=-lposix *Note Defining Variables::, for more details. Compiling For Multiple Architectures ==================================== You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their own directory. To do this, you can use GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. This is known as a "VPATH" build. With a non-GNU `make', it is safer to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use `make distclean' before reconfiguring for another architecture. On MacOS X 10.5 and later systems, you can create libraries and executables that work on multiple system types--known as "fat" or "universal" binaries--by specifying multiple `-arch' options to the compiler but only a single `-arch' option to the preprocessor. Like this: ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CPP="gcc -E" CXXCPP="g++ -E" This is not guaranteed to produce working output in all cases, you may have to build one architecture at a time and combine the results using the `lipo' tool if you have problems. Installation Names ================== By default, `make install' installs the package's commands under `/usr/local/bin', include files under `/usr/local/include', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PREFIX', where PREFIX must be an absolute file name. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you pass the option `--exec-prefix=PREFIX' to `configure', the package uses PREFIX as the prefix for installing programs and libraries. Documentation and other data files still use the regular prefix. In addition, if you use an unusual directory layout you can give options like `--bindir=DIR' to specify different values for particular kinds of files. Run `configure --help' for a list of the directories you can set and what kinds of files go in them. In general, the default for these options is expressed in terms of `${prefix}', so that specifying just `--prefix' will affect all of the other directory specifications that were not explicitly provided. The most portable way to affect installation locations is to pass the correct locations to `configure'; however, many packages provide one or both of the following shortcuts of passing variable assignments to the `make install' command line to change installation locations without having to reconfigure or recompile. The first method involves providing an override variable for each affected directory. For example, `make install prefix=/alternate/directory' will choose an alternate location for all directory configuration variables that were expressed in terms of `${prefix}'. Any directories that were specified during `configure', but not in terms of `${prefix}', must each be overridden at install time for the entire installation to be relocated. The approach of makefile variable overrides for each directory variable is required by the GNU Coding Standards, and ideally causes no recompilation. However, some platforms have known limitations with the semantics of shared libraries that end up requiring recompilation when using this method, particularly noticeable in packages that use GNU Libtool. The second method involves providing the `DESTDIR' variable. For example, `make install DESTDIR=/alternate/directory' will prepend `/alternate/directory' before all installation names. The approach of `DESTDIR' overrides is not required by the GNU Coding Standards, and does not work on platforms that have drive letters. On the other hand, it does better at avoiding recompilation issues, and works well even when some directory options were not specified in terms of `${prefix}' at `configure' time. Optional Features ================= If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving `configure' the option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. Some packages pay attention to `--enable-FEATURE' options to `configure', where FEATURE indicates an optional part of the package. They may also pay attention to `--with-PACKAGE' options, where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The `README' should mention any `--enable-' and `--with-' options that the package recognizes. For packages that use the X Window System, `configure' can usually find the X include and library files automatically, but if it doesn't, you can use the `configure' options `--x-includes=DIR' and `--x-libraries=DIR' to specify their locations. Some packages offer the ability to configure how verbose the execution of `make' will be. For these packages, running `./configure --enable-silent-rules' sets the default to minimal output, which can be overridden with `make V=1'; while running `./configure --disable-silent-rules' sets the default to verbose, which can be overridden with `make V=0'. Particular systems ================== On HP-UX, the default C compiler is not ANSI C compatible. If GNU CC is not installed, it is recommended to use the following options in order to use an ANSI C compiler: ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" and if that doesn't work, install pre-built binaries of GCC for HP-UX. On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot parse its `' header file. The option `-nodtk' can be used as a workaround. If GNU CC is not installed, it is therefore recommended to try ./configure CC="cc" and if that doesn't work, try ./configure CC="cc -nodtk" On Solaris, don't put `/usr/ucb' early in your `PATH'. This directory contains several dysfunctional programs; working variants of these programs are available in `/usr/bin'. So, if you need `/usr/ucb' in your `PATH', put it _after_ `/usr/bin'. On Haiku, software installed for all users goes in `/boot/common', not `/usr/local'. It is recommended to use the following options: ./configure --prefix=/boot/common Specifying the System Type ========================== There may be some features `configure' cannot figure out automatically, but needs to determine by the type of machine the package will run on. Usually, assuming the package is built to be run on the _same_ architectures, `configure' can figure that out, but if it prints a message saying it cannot guess the machine type, give it the `--build=TYPE' option. TYPE can either be a short name for the system type, such as `sun4', or a canonical name which has the form: CPU-COMPANY-SYSTEM where SYSTEM can have one of these forms: OS KERNEL-OS See the file `config.sub' for the possible values of each field. If `config.sub' isn't included in this package, then this package doesn't need to know the machine type. If you are _building_ compiler tools for cross-compiling, you should use the option `--target=TYPE' to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a platform different from the build platform, you should specify the "host" platform (i.e., that on which the generated programs will eventually be run) with `--host=TYPE'. Sharing Defaults ================ If you want to set default values for `configure' scripts to share, you can create a site shell script called `config.site' that gives default values for variables like `CC', `cache_file', and `prefix'. `configure' looks for `PREFIX/share/config.site' if it exists, then `PREFIX/etc/config.site' if it exists. Or, you can set the `CONFIG_SITE' environment variable to the location of the site script. A warning: not all `configure' scripts look for a site script. Defining Variables ================== Variables not defined in a site shell script can be set in the environment passed to `configure'. However, some packages may run configure again during the build, and the customized values of these variables may be lost. In order to avoid this problem, you should set them in the `configure' command line, using `VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc causes the specified `gcc' to be used as the C compiler (unless it is overridden in the site shell script). Unfortunately, this technique does not work for `CONFIG_SHELL' due to an Autoconf bug. Until the bug is fixed you can use this workaround: CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash `configure' Invocation ====================== `configure' recognizes the following options to control how it operates. `--help' `-h' Print a summary of all of the options to `configure', and exit. `--help=short' `--help=recursive' Print a summary of the options unique to this package's `configure', and exit. The `short' variant lists options used only in the top level, while the `recursive' variant lists options also present in any nested packages. `--version' `-V' Print the version of Autoconf used to generate the `configure' script, and exit. `--cache-file=FILE' Enable the cache: use and save the results of the tests in FILE, traditionally `config.cache'. FILE defaults to `/dev/null' to disable caching. `--config-cache' `-C' Alias for `--cache-file=config.cache'. `--quiet' `--silent' `-q' Do not print messages saying which checks are being made. To suppress all normal output, redirect it to `/dev/null' (any error messages will still be shown). `--srcdir=DIR' Look for the package's source code in directory DIR. Usually `configure' can determine that directory automatically. `--prefix=DIR' Use DIR as the installation prefix. *note Installation Names:: for more details, including other options available for fine-tuning the installation locations. `--no-create' `-n' Run the configure checks, but stop before creating any output files. `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. fakeroot-ng-0.18/log.h0000644000175000017500000000020712100450163012773 0ustar sunsun#ifndef LOG_H #define LOG_H bool init_log( const char * file_name, bool flush ); int get_log_fd(); void close_log(); #endif // LOG_H fakeroot-ng-0.18/unique_fd.h0000644000175000017500000000246312130061226014200 0ustar sunsun#ifndef UNIQUE_FD_H #define UNIQUE_FD_H #include #include #include "exceptions.h" struct unique_fd { int _fd; unique_fd( const unique_fd &rhs )=delete; unique_fd & operator=( const unique_fd &rhs )=delete; public: explicit unique_fd( int fd=-1, const char *exception_message=nullptr ) : _fd( fd>=0 ? fd : -1 ) { if( _fd<0 && exception_message ) throw errno_exception( exception_message ); } // Movers explicit unique_fd( unique_fd &&rhs ) { _fd=rhs._fd; rhs._fd=-1; } unique_fd & operator=( unique_fd &&rhs ) { _fd=rhs._fd; rhs._fd=-1; return *this; } // Destructor ~unique_fd() { if( _fd>=0 ) if( close(_fd)<0 ) throw errno_exception( "Close failed" ); } int get() const { return _fd; } int release() { int ret=get(); _fd=-1; return ret; } operator bool() const { return _fd>=0; } // File related operations bool flock( int operation ) { if( ::flock( get(), operation )<0 ) { if( errno==EWOULDBLOCK ) return false; throw errno_exception( "flock failed" ); } return true; } }; #endif // UNIQUE_FD_H fakeroot-ng-0.18/Makefile.am0000644000175000017500000000107112126212571014104 0ustar sunsunSUBDIRS=arch tests clean-local: $(MAKE) -C arch/$(target_os)/$(target_cpu) clean distclean-local: $(MAKE) -C arch/$(target_os)/$(target_cpu) distclean bin_PROGRAMS=fakeroot-ng man1_MANS = fakeroot-ng.man fakeroot_ng_SOURCES=main.cpp parent.h parent.cpp syscalls.h process.cpp file.cpp file_lie.cpp ptrace.cpp chroot.cpp \ credentials.cpp log.cpp daemon.cpp #fakeroot_ng_LDFLAGS=-Larch/$(target_os)/$(target_cpu) fakeroot_ng_LDADD=arch/$(target_os)/$(target_cpu)/libarch.a fakeroot_ng_CPPFLAGS=-I$(top_srcdir)/arch/$(target_os)/$(target_cpu) fakeroot-ng-0.18/configure.ac0000644000175000017500000001506312131751217014345 0ustar sunsun# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ(2.61) AC_INIT([fakeroot-ng], [0.18], [shachar@debian.org]) AC_CANONICAL_TARGET() AM_INIT_AUTOMAKE([no-dist]) AC_CONFIG_SRCDIR([parent.h]) AC_CONFIG_HEADER([config.h]) AC_USE_SYSTEM_EXTENSIONS # Checks for programs. AC_PROG_CXX AC_PROG_CC AC_PROG_CPP AC_PROG_AWK AC_PROG_INSTALL AC_PROG_LN_S AC_PROG_MAKE_SET AC_PROG_MKDIR_P AC_PROG_RANLIB AC_LANG(C) # Checks for libraries. # Checks for header files. AC_HEADER_STDC AC_HEADER_SYS_WAIT AC_CHECK_HEADERS([fcntl.h limits.h stdlib.h string.h sys/file.h sys/socket.h sys/time.h unistd.h sys/prctl.h]) # Checks for typedefs, structures, and compiler characteristics. AC_HEADER_STDBOOL AC_C_CONST AC_TYPE_UID_T AC_TYPE_MODE_T AC_TYPE_PID_T AC_TYPE_SIZE_T AC_TYPE_SSIZE_T AC_CHECK_DECLS([PR_SET_PTRACER],[],[],[#include ]) dnl Globally define the root UID AC_DEFINE([ROOT_UID],[0],[UID for root]) AC_DEFINE([ROOT_GID],[0],[GID for root]) dnl Check whether we have PTRACE_GETREGS AC_MSG_CHECKING([for PTRACE_GETREGS]) AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([ #include ], [ptrace(PTRACE_GETREGS, 0, 0, 0);])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTRACE_GETREGS], [1], [Ptrace defines a single syscall for getting all registers]) ], [AC_MSG_RESULT([no])]) dnl Check whether we have PTRACE_PEEKUSER AC_MSG_CHECKING([for PTRACE_PEEKUSER]) AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([ #include ], [ptrace(PTRACE_PEEKUSER, 0, 0, 0);])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_PTRACE_PEEKUSER], [1], [Ptrace defines a syscall for getting a single register]) ], [AC_MSG_RESULT([no])]) dnl Check which std::map variant to use AC_LANG_PUSH(C++) #AC_LANG_WERROR AC_MSG_CHECKING([what flags are needed for compiler support of the ISO C++11 standard]) saved_CXXFLAGS=$CXXFLAGS CXXFLAGS="$saved_CXXFLAGS -Werror" AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([ #include class testcpp11 { public: testcpp11() = default; }; ], [ std::unordered_map test; decltype(test)::iterator iterator; int *nullable=nullptr; int i; if( nullable!=0 ) nullable=&i; ])], [ AC_MSG_RESULT([none]) CXXFLAGS="$saved_CXXFLAGS" ], [ CXXFLAGS="$saved_CXXFLAGS -std=c++11 -Werror" AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([ #include class testcpp11 { public: testcpp11() = default; }; ], [ std::unordered_map test; decltype(test)::iterator iterator; int *nullable=nullptr; int i; if( nullable!=0 ) nullable=&i; ])], [ AC_MSG_RESULT([-std=c++11]) CXXFLAGS="$saved_CXXFLAGS -std=c++11" ], [ AC_MSG_RESULT([not supported]) AC_ERROR([Fakeroot-ng needs a compiler that supports C++11. If you are using gcc, that means version 4.7 or higher.]) ] ) ] ) dnl gcc supports indicating that a function is a printf style function. It then has protections against format string dnl mismatches AC_MSG_CHECKING([whether compiler supports custom printf style protection]) AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([int dummy( const char *format, ... ) __attribute__ ((format(printf, 1, 2)));],[] )], [ AC_MSG_RESULT([__attribute__ ((format(...)))]) AC_DEFINE([COMPHINT_PRINTF( f, c )], [__attribute__ (( format ( printf, f, c )))], [How to tell the compiler that this is a printf style function]) ], [ AC_MSG_RESULT([no]) AC_MSG_ERROR([Compiler does not support format string checking on custom functions]) ] ) AC_LANG_POP # Checks for library functions. AC_FUNC_CHOWN AC_FUNC_ERROR_AT_LINE AC_FUNC_FORK AC_FUNC_LSTAT AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK AC_FUNC_VPRINTF AC_FUNC_MMAP AC_CHECK_FUNCS([ftruncate getcwd memset mkdir munmap realpath select socket strchr strerror strtoul]) AC_MSG_CHECKING([whether openat class functions are supported]) AC_COMPILE_IFELSE( [AC_LANG_PROGRAM([ #include #include ], [struct stat stat; fstatat(AT_FDCWD, "/etc/passwd", &stat, AT_SYMLINK_NOFOLLOW);])], [ AC_MSG_RESULT([yes]) AC_DEFINE([HAVE_OPENAT], [1], [Supports the openat class of functions])], [ dnl Let's try again, this time with _ATFILE_SOURCE at the beginning AC_COMPILE_IFELSE( [ AC_LANG_PROGRAM([ #define _ATFILE_SOURCE #include #include ], [struct stat stat; fstatat(AT_FDCWD, "/etc/passwd", &stat, AT_SYMLINK_NOFOLLOW);])], [ AC_MSG_RESULT([_ATFILE_SOURCE]) AC_DEFINE([HAVE_OPENAT], [1]) AC_DEFINE([_ATFILE_SOURCE],[], [Enable openat functions]) ], [ AC_MSG_RESULT([no]) ] ) ] ) AC_MSG_CHECKING([what alternate location to use for shared memory files]) AC_ARG_WITH([memdir], [AC_HELP_STRING([--with-memdir=DIR],[Where to create shared memory files (default /tmp)])], [ if [[ "$with_memdir" ]] then AC_MSG_RESULT([$with_memdir]) AC_DEFINE_UNQUOTED([DEFAULT_TMPDIR], ["$with_memdir"]) fi ], [ AC_MSG_RESULT([/tmp]) AC_DEFINE([DEFAULT_TMPDIR], ["/tmp"], [Where to create shared memory files if no environment overrides]) ]) # Custom steps dnl Canoninize the canonical system names [ if [ "$target_os" = "linux-gnu" ] then target_os=linux fi case "$target_cpu" in i686|i586|i486) target_cpu=i386 ;; esac ] # Check whether we are ported to this platform AC_MSG_CHECKING([whether platform $target_os/$target_cpu is supported]) [ if [ ! -f "$srcdir/arch/$target_os/$target_cpu/platform_specific.h" ] then ] AC_MSG_RESULT(no) echo "$srcdir" AC_MSG_ERROR(Platform detected is not yet supported.) [ else ] AC_MSG_RESULT([yes]) [ fi ] dnl We generate all Makefiles for all platforms, and then only invoke those for the platforms we need AC_CONFIG_FILES([Makefile tests/Makefile arch/Makefile arch/$target_os/Makefile.template arch/$target_os/$target_cpu/Makefile]) AC_OUTPUT fakeroot-ng-0.18/install-sh0000755000175000017500000003253712131751664014076 0ustar sunsun#!/bin/sh # install - install a program, script, or datafile scriptversion=2009-04-28.21; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the # following copyright and license. # # Copyright (C) 1994 X Consortium # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN # AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- # TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # # Except as contained in this notice, the name of the X Consortium shall not # be used in advertising or otherwise to promote the sale, use or other deal- # ings in this Software without prior written authorization from the X Consor- # tium. # # # FSF changes to this file are in the public domain. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. nl=' ' IFS=" "" $nl" # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit=${DOITPROG-} if test -z "$doit"; then doit_exec=exec else doit_exec=$doit fi # Put in absolute file names if you don't have them in your path; # or use environment vars. chgrpprog=${CHGRPPROG-chgrp} chmodprog=${CHMODPROG-chmod} chownprog=${CHOWNPROG-chown} cmpprog=${CMPPROG-cmp} cpprog=${CPPROG-cp} mkdirprog=${MKDIRPROG-mkdir} mvprog=${MVPROG-mv} rmprog=${RMPROG-rm} stripprog=${STRIPPROG-strip} posix_glob='?' initialize_posix_glob=' test "$posix_glob" != "?" || { if (set -f) 2>/dev/null; then posix_glob= else posix_glob=: fi } ' posix_mkdir= # Desired mode of installed file. mode=0755 chgrpcmd= chmodcmd=$chmodprog chowncmd= mvcmd=$mvprog rmcmd="$rmprog -f" stripcmd= src= dst= dir_arg= dst_arg= copy_on_change=false no_target_directory= usage="\ Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE or: $0 [OPTION]... SRCFILES... DIRECTORY or: $0 [OPTION]... -t DIRECTORY SRCFILES... or: $0 [OPTION]... -d DIRECTORIES... In the 1st form, copy SRCFILE to DSTFILE. In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. In the 4th, create DIRECTORIES. Options: --help display this help and exit. --version display version info and exit. -c (ignored) -C install only if different (preserve the last data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. -s $stripprog installed files. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG " while test $# -ne 0; do case $1 in -c) ;; -C) copy_on_change=true;; -d) dir_arg=true;; -g) chgrpcmd="$chgrpprog $2" shift;; --help) echo "$usage"; exit $?;; -m) mode=$2 case $mode in *' '* | *' '* | *' '* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -s) stripcmd=$stripprog;; -t) dst_arg=$2 shift;; -T) no_target_directory=true;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then # When -d is used, all remaining arguments are directories to create. # When -t is used, the destination is already specified. # Otherwise, the last argument is the destination. Remove it from $@. for arg do if test -n "$dst_arg"; then # $@ is not empty: it contains at least $arg. set fnord "$@" "$dst_arg" shift # fnord fi shift # arg dst_arg=$arg done fi if test $# -eq 0; then if test -z "$dir_arg"; then echo "$0: no input file specified." >&2 exit 1 fi # It's OK to call `install-sh -d' without argument. # This can happen when creating conditional directories. exit 0 fi if test -z "$dir_arg"; then trap '(exit $?); exit' 1 2 13 15 # Set umask so as not to create temps with too-generous modes. # However, 'strip' requires both read and write access to temps. case $mode in # Optimize common cases. *644) cp_umask=133;; *755) cp_umask=22;; *[0-7]) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw='% 200' fi cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; *) if test -z "$stripcmd"; then u_plus_rw= else u_plus_rw=,u+rw fi cp_umask=$mode$u_plus_rw;; esac fi for src do # Protect names starting with `-'. case $src in -*) src=./$src;; esac if test -n "$dir_arg"; then dst=$src dstdir=$dst test -d "$dstdir" dstdir_status=$? else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if test ! -f "$src" && test ! -d "$src"; then echo "$0: $src does not exist." >&2 exit 1 fi if test -z "$dst_arg"; then echo "$0: no destination specified." >&2 exit 1 fi dst=$dst_arg # Protect names starting with `-'. case $dst in -*) dst=./$dst;; esac # If destination is a directory, append the input filename; won't work # if double slashes aren't ignored. if test -d "$dst"; then if test -n "$no_target_directory"; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dst=$dstdir/`basename "$src"` dstdir_status=0 else # Prefer dirname, but fall back on a substitute if dirname fails. dstdir=` (dirname "$dst") 2>/dev/null || expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$dst" : 'X\(//\)[^/]' \| \ X"$dst" : 'X\(//\)$' \| \ X"$dst" : 'X\(/\)' \| . 2>/dev/null || echo X"$dst" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q' ` test -d "$dstdir" dstdir_status=$? fi fi obsolete_mkdir_used=false if test $dstdir_status != 0; then case $posix_mkdir in '') # Create intermediate dirs using mode 755 as modified by the umask. # This is like FreeBSD 'install' as of 1997-10-28. umask=`umask` case $stripcmd.$umask in # Optimize common cases. *[2367][2367]) mkdir_umask=$umask;; .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; *[0-7]) mkdir_umask=`expr $umask + 22 \ - $umask % 100 % 40 + $umask % 20 \ - $umask % 10 % 4 + $umask % 2 `;; *) mkdir_umask=$umask,go-w;; esac # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then mkdir_mode=-m$mode else mkdir_mode= fi posix_mkdir=false case $umask in *[123567][0-7][0-7]) # POSIX mkdir -p sets u+wx bits regardless of umask, which # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ;; *) tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 if (umask $mkdir_umask && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 then if test -z "$dir_arg" || { # Check for POSIX incompatibilities with -m. # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or # other-writeable bit of parent directory when it shouldn't. # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. ls_ld_tmpdir=`ls -ld "$tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/d" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null fi trap '' 0;; esac;; esac if $posix_mkdir && ( umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ) then : else # The umask is ridiculous, or mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. case $dstdir in /*) prefix='/';; -*) prefix='./';; *) prefix='';; esac eval "$initialize_posix_glob" oIFS=$IFS IFS=/ $posix_glob set -f set fnord $dstdir shift $posix_glob set +f IFS=$oIFS prefixes= for d do test -z "$d" && continue prefix=$prefix$d if test -d "$prefix"; then prefixes= else if $posix_mkdir; then (umask=$mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 else case $prefix in *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; *) qprefix=$prefix;; esac prefixes="$prefixes '$qprefix'" fi fi prefix=$prefix/ done if test -n "$prefixes"; then # Don't fail if two instances are running concurrently. (umask $mkdir_umask && eval "\$doit_exec \$mkdirprog $prefixes") || test -d "$dstdir" || exit 1 obsolete_mkdir_used=true fi fi fi if test -n "$dir_arg"; then { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 else # Make a couple of temp file names in the proper directory. dsttmp=$dstdir/_inst.$$_ rmtmp=$dstdir/_rm.$$_ # Trap to clean up those temp files at exit. trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 # Copy the file name to the temp name. (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && # and set any options; do chmod last to preserve setuid bits. # # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $cpprog $src $dsttmp" command. # { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && # If -C, don't bother to copy if it wouldn't change the file. if $copy_on_change && old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && eval "$initialize_posix_glob" && $posix_glob set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && $posix_glob set +f && test "$old" = "$new" && $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 then rm -f "$dsttmp" else # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || # The rename failed, perhaps because mv can't rename something else # to itself, or perhaps because mv is so ancient that it does not # support -f. { # Now remove or move aside any old file at destination location. # We try this two ways since rm can't unlink itself on some # systems and the destination file might be busy for other # reasons. In this case, the final cleanup might fail but the new # file should still install successfully. { test ! -f "$dst" || $doit $rmcmd -f "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 } } && # Now rename the file to the real destination. $doit $mvcmd "$dsttmp" "$dst" } fi || exit 1 trap '' 0 fi done # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: fakeroot-ng-0.18/Makefile.in0000644000175000017500000011565012131751664014135 0ustar sunsun# Makefile.in generated by automake 1.11.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, # 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, # Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ bin_PROGRAMS = fakeroot-ng$(EXEEXT) subdir = . DIST_COMMON = INSTALL NEWS README AUTHORS ChangeLog \ $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ $(top_srcdir)/configure $(am__configure_deps) \ $(srcdir)/config.h.in depcomp ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = am__installdirs = "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)" PROGRAMS = $(bin_PROGRAMS) am_fakeroot_ng_OBJECTS = fakeroot_ng-main.$(OBJEXT) \ fakeroot_ng-parent.$(OBJEXT) fakeroot_ng-process.$(OBJEXT) \ fakeroot_ng-file.$(OBJEXT) fakeroot_ng-file_lie.$(OBJEXT) \ fakeroot_ng-ptrace.$(OBJEXT) fakeroot_ng-chroot.$(OBJEXT) \ fakeroot_ng-credentials.$(OBJEXT) fakeroot_ng-log.$(OBJEXT) \ fakeroot_ng-daemon.$(OBJEXT) fakeroot_ng_OBJECTS = $(am_fakeroot_ng_OBJECTS) fakeroot_ng_DEPENDENCIES = arch/$(target_os)/$(target_cpu)/libarch.a DEFAULT_INCLUDES = -I.@am__isrc@ depcomp = $(SHELL) $(top_srcdir)/depcomp am__depfiles_maybe = depfiles am__mv = mv -f CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) CXXLD = $(CXX) CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \ -o $@ COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) CCLD = $(CC) LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ SOURCES = $(fakeroot_ng_SOURCES) RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ html-recursive info-recursive install-data-recursive \ install-dvi-recursive install-exec-recursive \ install-html-recursive install-info-recursive \ install-pdf-recursive install-ps-recursive install-recursive \ installcheck-recursive installdirs-recursive pdf-recursive \ ps-recursive uninstall-recursive am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; am__vpath_adj = case $$p in \ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ *) f=$$p;; \ esac; am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; am__install_max = 40 am__nobase_strip_setup = \ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` am__nobase_strip = \ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" am__nobase_list = $(am__nobase_strip_setup); \ for p in $$list; do echo "$$p $$p"; done | \ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ if (++n[$$2] == $(am__install_max)) \ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ END { for (dir in files) print dir, files[dir] }' am__base_list = \ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' man1dir = $(mandir)/man1 NROFF = nroff MANS = $(man1_MANS) RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ distclean-recursive maintainer-clean-recursive AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS ETAGS = etags CTAGS = ctags DIST_SUBDIRS = $(SUBDIRS) ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ CXXDEPMODE = @CXXDEPMODE@ CXXFLAGS = @CXXFLAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ ac_ct_CXX = @ac_ct_CXX@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ SUBDIRS = arch tests man1_MANS = fakeroot-ng.man fakeroot_ng_SOURCES = main.cpp parent.h parent.cpp syscalls.h process.cpp file.cpp file_lie.cpp ptrace.cpp chroot.cpp \ credentials.cpp log.cpp daemon.cpp #fakeroot_ng_LDFLAGS=-Larch/$(target_os)/$(target_cpu) fakeroot_ng_LDADD = arch/$(target_os)/$(target_cpu)/libarch.a fakeroot_ng_CPPFLAGS = -I$(top_srcdir)/arch/$(target_os)/$(target_cpu) all: config.h $(MAKE) $(AM_MAKEFLAGS) all-recursive .SUFFIXES: .SUFFIXES: .cpp .o .obj am--refresh: @: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ echo ' cd $(srcdir) && $(AUTOMAKE) --gnu'; \ $(am__cd) $(srcdir) && $(AUTOMAKE) --gnu \ && exit 0; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --gnu Makefile .PRECIOUS: Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ echo ' $(SHELL) ./config.status'; \ $(SHELL) ./config.status;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) $(SHELL) ./config.status --recheck $(top_srcdir)/configure: $(am__configure_deps) $(am__cd) $(srcdir) && $(AUTOCONF) $(ACLOCAL_M4): $(am__aclocal_m4_deps) $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) $(am__aclocal_m4_deps): config.h: stamp-h1 @if test ! -f $@; then \ rm -f stamp-h1; \ $(MAKE) $(AM_MAKEFLAGS) stamp-h1; \ else :; fi stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status @rm -f stamp-h1 cd $(top_builddir) && $(SHELL) ./config.status config.h $(srcdir)/config.h.in: $(am__configure_deps) ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) rm -f stamp-h1 touch $@ distclean-hdr: -rm -f config.h stamp-h1 install-binPROGRAMS: $(bin_PROGRAMS) @$(NORMAL_INSTALL) test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)" @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ for p in $$list; do echo "$$p $$p"; done | \ sed 's/$(EXEEXT)$$//' | \ while read p p1; do if test -f $$p; \ then echo "$$p"; echo "$$p"; else :; fi; \ done | \ sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ sed 'N;N;N;s,\n, ,g' | \ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ if ($$2 == $$4) files[d] = files[d] " " $$1; \ else { print "f", $$3 "/" $$4, $$1; } } \ END { for (d in files) print "f", d, files[d] }' | \ while read type dir files; do \ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ test -z "$$files" || { \ echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ } \ ; done uninstall-binPROGRAMS: @$(NORMAL_UNINSTALL) @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ files=`for p in $$list; do echo "$$p"; done | \ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ -e 's/$$/$(EXEEXT)/' `; \ test -n "$$list" || exit 0; \ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ cd "$(DESTDIR)$(bindir)" && rm -f $$files clean-binPROGRAMS: -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS) fakeroot-ng$(EXEEXT): $(fakeroot_ng_OBJECTS) $(fakeroot_ng_DEPENDENCIES) @rm -f fakeroot-ng$(EXEEXT) $(CXXLINK) $(fakeroot_ng_OBJECTS) $(fakeroot_ng_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-chroot.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-credentials.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-daemon.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-file.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-file_lie.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-log.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-main.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-parent.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-process.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fakeroot_ng-ptrace.Po@am__quote@ .cpp.o: @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< .cpp.obj: @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` fakeroot_ng-main.o: main.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-main.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-main.Tpo -c -o fakeroot_ng-main.o `test -f 'main.cpp' || echo '$(srcdir)/'`main.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-main.Tpo $(DEPDIR)/fakeroot_ng-main.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='main.cpp' object='fakeroot_ng-main.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-main.o `test -f 'main.cpp' || echo '$(srcdir)/'`main.cpp fakeroot_ng-main.obj: main.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-main.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-main.Tpo -c -o fakeroot_ng-main.obj `if test -f 'main.cpp'; then $(CYGPATH_W) 'main.cpp'; else $(CYGPATH_W) '$(srcdir)/main.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-main.Tpo $(DEPDIR)/fakeroot_ng-main.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='main.cpp' object='fakeroot_ng-main.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-main.obj `if test -f 'main.cpp'; then $(CYGPATH_W) 'main.cpp'; else $(CYGPATH_W) '$(srcdir)/main.cpp'; fi` fakeroot_ng-parent.o: parent.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-parent.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-parent.Tpo -c -o fakeroot_ng-parent.o `test -f 'parent.cpp' || echo '$(srcdir)/'`parent.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-parent.Tpo $(DEPDIR)/fakeroot_ng-parent.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='parent.cpp' object='fakeroot_ng-parent.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-parent.o `test -f 'parent.cpp' || echo '$(srcdir)/'`parent.cpp fakeroot_ng-parent.obj: parent.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-parent.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-parent.Tpo -c -o fakeroot_ng-parent.obj `if test -f 'parent.cpp'; then $(CYGPATH_W) 'parent.cpp'; else $(CYGPATH_W) '$(srcdir)/parent.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-parent.Tpo $(DEPDIR)/fakeroot_ng-parent.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='parent.cpp' object='fakeroot_ng-parent.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-parent.obj `if test -f 'parent.cpp'; then $(CYGPATH_W) 'parent.cpp'; else $(CYGPATH_W) '$(srcdir)/parent.cpp'; fi` fakeroot_ng-process.o: process.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-process.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-process.Tpo -c -o fakeroot_ng-process.o `test -f 'process.cpp' || echo '$(srcdir)/'`process.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-process.Tpo $(DEPDIR)/fakeroot_ng-process.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='process.cpp' object='fakeroot_ng-process.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-process.o `test -f 'process.cpp' || echo '$(srcdir)/'`process.cpp fakeroot_ng-process.obj: process.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-process.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-process.Tpo -c -o fakeroot_ng-process.obj `if test -f 'process.cpp'; then $(CYGPATH_W) 'process.cpp'; else $(CYGPATH_W) '$(srcdir)/process.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-process.Tpo $(DEPDIR)/fakeroot_ng-process.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='process.cpp' object='fakeroot_ng-process.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-process.obj `if test -f 'process.cpp'; then $(CYGPATH_W) 'process.cpp'; else $(CYGPATH_W) '$(srcdir)/process.cpp'; fi` fakeroot_ng-file.o: file.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-file.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-file.Tpo -c -o fakeroot_ng-file.o `test -f 'file.cpp' || echo '$(srcdir)/'`file.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-file.Tpo $(DEPDIR)/fakeroot_ng-file.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='file.cpp' object='fakeroot_ng-file.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-file.o `test -f 'file.cpp' || echo '$(srcdir)/'`file.cpp fakeroot_ng-file.obj: file.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-file.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-file.Tpo -c -o fakeroot_ng-file.obj `if test -f 'file.cpp'; then $(CYGPATH_W) 'file.cpp'; else $(CYGPATH_W) '$(srcdir)/file.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-file.Tpo $(DEPDIR)/fakeroot_ng-file.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='file.cpp' object='fakeroot_ng-file.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-file.obj `if test -f 'file.cpp'; then $(CYGPATH_W) 'file.cpp'; else $(CYGPATH_W) '$(srcdir)/file.cpp'; fi` fakeroot_ng-file_lie.o: file_lie.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-file_lie.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-file_lie.Tpo -c -o fakeroot_ng-file_lie.o `test -f 'file_lie.cpp' || echo '$(srcdir)/'`file_lie.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-file_lie.Tpo $(DEPDIR)/fakeroot_ng-file_lie.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='file_lie.cpp' object='fakeroot_ng-file_lie.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-file_lie.o `test -f 'file_lie.cpp' || echo '$(srcdir)/'`file_lie.cpp fakeroot_ng-file_lie.obj: file_lie.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-file_lie.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-file_lie.Tpo -c -o fakeroot_ng-file_lie.obj `if test -f 'file_lie.cpp'; then $(CYGPATH_W) 'file_lie.cpp'; else $(CYGPATH_W) '$(srcdir)/file_lie.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-file_lie.Tpo $(DEPDIR)/fakeroot_ng-file_lie.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='file_lie.cpp' object='fakeroot_ng-file_lie.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-file_lie.obj `if test -f 'file_lie.cpp'; then $(CYGPATH_W) 'file_lie.cpp'; else $(CYGPATH_W) '$(srcdir)/file_lie.cpp'; fi` fakeroot_ng-ptrace.o: ptrace.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-ptrace.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-ptrace.Tpo -c -o fakeroot_ng-ptrace.o `test -f 'ptrace.cpp' || echo '$(srcdir)/'`ptrace.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-ptrace.Tpo $(DEPDIR)/fakeroot_ng-ptrace.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='ptrace.cpp' object='fakeroot_ng-ptrace.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-ptrace.o `test -f 'ptrace.cpp' || echo '$(srcdir)/'`ptrace.cpp fakeroot_ng-ptrace.obj: ptrace.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-ptrace.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-ptrace.Tpo -c -o fakeroot_ng-ptrace.obj `if test -f 'ptrace.cpp'; then $(CYGPATH_W) 'ptrace.cpp'; else $(CYGPATH_W) '$(srcdir)/ptrace.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-ptrace.Tpo $(DEPDIR)/fakeroot_ng-ptrace.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='ptrace.cpp' object='fakeroot_ng-ptrace.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-ptrace.obj `if test -f 'ptrace.cpp'; then $(CYGPATH_W) 'ptrace.cpp'; else $(CYGPATH_W) '$(srcdir)/ptrace.cpp'; fi` fakeroot_ng-chroot.o: chroot.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-chroot.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-chroot.Tpo -c -o fakeroot_ng-chroot.o `test -f 'chroot.cpp' || echo '$(srcdir)/'`chroot.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-chroot.Tpo $(DEPDIR)/fakeroot_ng-chroot.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='chroot.cpp' object='fakeroot_ng-chroot.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-chroot.o `test -f 'chroot.cpp' || echo '$(srcdir)/'`chroot.cpp fakeroot_ng-chroot.obj: chroot.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-chroot.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-chroot.Tpo -c -o fakeroot_ng-chroot.obj `if test -f 'chroot.cpp'; then $(CYGPATH_W) 'chroot.cpp'; else $(CYGPATH_W) '$(srcdir)/chroot.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-chroot.Tpo $(DEPDIR)/fakeroot_ng-chroot.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='chroot.cpp' object='fakeroot_ng-chroot.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-chroot.obj `if test -f 'chroot.cpp'; then $(CYGPATH_W) 'chroot.cpp'; else $(CYGPATH_W) '$(srcdir)/chroot.cpp'; fi` fakeroot_ng-credentials.o: credentials.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-credentials.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-credentials.Tpo -c -o fakeroot_ng-credentials.o `test -f 'credentials.cpp' || echo '$(srcdir)/'`credentials.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-credentials.Tpo $(DEPDIR)/fakeroot_ng-credentials.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='credentials.cpp' object='fakeroot_ng-credentials.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-credentials.o `test -f 'credentials.cpp' || echo '$(srcdir)/'`credentials.cpp fakeroot_ng-credentials.obj: credentials.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-credentials.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-credentials.Tpo -c -o fakeroot_ng-credentials.obj `if test -f 'credentials.cpp'; then $(CYGPATH_W) 'credentials.cpp'; else $(CYGPATH_W) '$(srcdir)/credentials.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-credentials.Tpo $(DEPDIR)/fakeroot_ng-credentials.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='credentials.cpp' object='fakeroot_ng-credentials.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-credentials.obj `if test -f 'credentials.cpp'; then $(CYGPATH_W) 'credentials.cpp'; else $(CYGPATH_W) '$(srcdir)/credentials.cpp'; fi` fakeroot_ng-log.o: log.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-log.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-log.Tpo -c -o fakeroot_ng-log.o `test -f 'log.cpp' || echo '$(srcdir)/'`log.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-log.Tpo $(DEPDIR)/fakeroot_ng-log.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='log.cpp' object='fakeroot_ng-log.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-log.o `test -f 'log.cpp' || echo '$(srcdir)/'`log.cpp fakeroot_ng-log.obj: log.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-log.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-log.Tpo -c -o fakeroot_ng-log.obj `if test -f 'log.cpp'; then $(CYGPATH_W) 'log.cpp'; else $(CYGPATH_W) '$(srcdir)/log.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-log.Tpo $(DEPDIR)/fakeroot_ng-log.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='log.cpp' object='fakeroot_ng-log.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-log.obj `if test -f 'log.cpp'; then $(CYGPATH_W) 'log.cpp'; else $(CYGPATH_W) '$(srcdir)/log.cpp'; fi` fakeroot_ng-daemon.o: daemon.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-daemon.o -MD -MP -MF $(DEPDIR)/fakeroot_ng-daemon.Tpo -c -o fakeroot_ng-daemon.o `test -f 'daemon.cpp' || echo '$(srcdir)/'`daemon.cpp @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-daemon.Tpo $(DEPDIR)/fakeroot_ng-daemon.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='daemon.cpp' object='fakeroot_ng-daemon.o' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-daemon.o `test -f 'daemon.cpp' || echo '$(srcdir)/'`daemon.cpp fakeroot_ng-daemon.obj: daemon.cpp @am__fastdepCXX_TRUE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fakeroot_ng-daemon.obj -MD -MP -MF $(DEPDIR)/fakeroot_ng-daemon.Tpo -c -o fakeroot_ng-daemon.obj `if test -f 'daemon.cpp'; then $(CYGPATH_W) 'daemon.cpp'; else $(CYGPATH_W) '$(srcdir)/daemon.cpp'; fi` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/fakeroot_ng-daemon.Tpo $(DEPDIR)/fakeroot_ng-daemon.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='daemon.cpp' object='fakeroot_ng-daemon.obj' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fakeroot_ng_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fakeroot_ng-daemon.obj `if test -f 'daemon.cpp'; then $(CYGPATH_W) 'daemon.cpp'; else $(CYGPATH_W) '$(srcdir)/daemon.cpp'; fi` install-man1: $(man1_MANS) @$(NORMAL_INSTALL) test -z "$(man1dir)" || $(MKDIR_P) "$(DESTDIR)$(man1dir)" @list='$(man1_MANS)'; test -n "$(man1dir)" || exit 0; \ { for i in $$list; do echo "$$i"; done; \ } | while read p; do \ if test -f $$p; then d=; else d="$(srcdir)/"; fi; \ echo "$$d$$p"; echo "$$p"; \ done | \ sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \ sed 'N;N;s,\n, ,g' | { \ list=; while read file base inst; do \ if test "$$base" = "$$inst"; then list="$$list $$file"; else \ echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \ $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \ fi; \ done; \ for i in $$list; do echo "$$i"; done | $(am__base_list) | \ while read files; do \ test -z "$$files" || { \ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \ $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \ done; } uninstall-man1: @$(NORMAL_UNINSTALL) @list='$(man1_MANS)'; test -n "$(man1dir)" || exit 0; \ files=`{ for i in $$list; do echo "$$i"; done; \ } | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \ -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \ test -z "$$files" || { \ echo " ( cd '$(DESTDIR)$(man1dir)' && rm -f" $$files ")"; \ cd "$(DESTDIR)$(man1dir)" && rm -f $$files; } # This directory's subdirectories are mostly independent; you can cd # into them and run `make' without going through this Makefile. # To change the values of `make' variables: instead of editing Makefiles, # (1) if the variable is set in `config.status', edit `config.status' # (which will cause the Makefiles to be regenerated when you run `make'); # (2) otherwise, pass the desired values on the `make' command line. $(RECURSIVE_TARGETS): @fail= failcom='exit 1'; \ for f in x $$MAKEFLAGS; do \ case $$f in \ *=* | --[!k]*);; \ *k*) failcom='fail=yes';; \ esac; \ done; \ dot_seen=no; \ target=`echo $@ | sed s/-recursive//`; \ list='$(SUBDIRS)'; for subdir in $$list; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ dot_seen=yes; \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done; \ if test "$$dot_seen" = "no"; then \ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ fi; test -z "$$fail" $(RECURSIVE_CLEAN_TARGETS): @fail= failcom='exit 1'; \ for f in x $$MAKEFLAGS; do \ case $$f in \ *=* | --[!k]*);; \ *k*) failcom='fail=yes';; \ esac; \ done; \ dot_seen=no; \ case "$@" in \ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ *) list='$(SUBDIRS)' ;; \ esac; \ rev=''; for subdir in $$list; do \ if test "$$subdir" = "."; then :; else \ rev="$$subdir $$rev"; \ fi; \ done; \ rev="$$rev ."; \ target=`echo $@ | sed s/-recursive//`; \ for subdir in $$rev; do \ echo "Making $$target in $$subdir"; \ if test "$$subdir" = "."; then \ local_target="$$target-am"; \ else \ local_target="$$target"; \ fi; \ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ || eval $$failcom; \ done && test -z "$$fail" tags-recursive: list='$(SUBDIRS)'; for subdir in $$list; do \ test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ done ctags-recursive: list='$(SUBDIRS)'; for subdir in $$list; do \ test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ done ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ mkid -fID $$unique tags: TAGS TAGS: tags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ include_option=--etags-include; \ empty_fix=.; \ else \ include_option=--include; \ empty_fix=; \ fi; \ list='$(SUBDIRS)'; for subdir in $$list; do \ if test "$$subdir" = .; then :; else \ test ! -f $$subdir/TAGS || \ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ fi; \ done; \ list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ if test $$# -gt 0; then \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ "$$@" $$unique; \ else \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ $$unique; \ fi; \ fi ctags: CTAGS CTAGS: ctags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags check-am: all-am check: check-recursive all-am: Makefile $(PROGRAMS) $(MANS) config.h installdirs: installdirs-recursive installdirs-am: for dir in "$(DESTDIR)$(bindir)" "$(DESTDIR)$(man1dir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done install: install-recursive install-exec: install-exec-recursive install-data: install-data-recursive uninstall: uninstall-recursive install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-recursive install-strip: $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ `test -z '$(STRIP)' || \ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-recursive clean-am: clean-binPROGRAMS clean-generic clean-local mostlyclean-am distclean: distclean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf ./$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-local distclean-tags dvi: dvi-recursive dvi-am: html: html-recursive html-am: info: info-recursive info-am: install-data-am: install-man install-dvi: install-dvi-recursive install-dvi-am: install-exec-am: install-binPROGRAMS install-html: install-html-recursive install-html-am: install-info: install-info-recursive install-info-am: install-man: install-man1 install-pdf: install-pdf-recursive install-pdf-am: install-ps: install-ps-recursive install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-recursive -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache -rm -rf ./$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-recursive mostlyclean-am: mostlyclean-compile mostlyclean-generic pdf: pdf-recursive pdf-am: ps: ps-recursive ps-am: uninstall-am: uninstall-binPROGRAMS uninstall-man uninstall-man: uninstall-man1 .MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) all \ ctags-recursive install-am install-strip tags-recursive .PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ all all-am am--refresh check check-am clean clean-binPROGRAMS \ clean-generic clean-local ctags ctags-recursive distclean \ distclean-compile distclean-generic distclean-hdr \ distclean-local distclean-tags dvi dvi-am html html-am info \ info-am install install-am install-binPROGRAMS install-data \ install-data-am install-dvi install-dvi-am install-exec \ install-exec-am install-html install-html-am install-info \ install-info-am install-man install-man1 install-pdf \ install-pdf-am install-ps install-ps-am install-strip \ installcheck installcheck-am installdirs installdirs-am \ maintainer-clean maintainer-clean-generic mostlyclean \ mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \ tags tags-recursive uninstall uninstall-am \ uninstall-binPROGRAMS uninstall-man uninstall-man1 clean-local: $(MAKE) -C arch/$(target_os)/$(target_cpu) clean distclean-local: $(MAKE) -C arch/$(target_os)/$(target_cpu) distclean # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: fakeroot-ng-0.18/arch/0000755000175000017500000000000012131751664012775 5ustar sunsunfakeroot-ng-0.18/arch/Makefile.am0000644000175000017500000000006211047053743015025 0ustar sunsunall-local: $(MAKE) -C $(target_os)/$(target_cpu) fakeroot-ng-0.18/arch/platform.h0000644000175000017500000001311111461300537014761 0ustar sunsun#ifndef PLATFORM_H #define PLATFORM_H #ifdef __cplusplus extern "C" { #endif /* Platform specific definitinos go in a special file */ #include "platform_specific.h" /* Functions for abstracting the details of registers and memory layout for interpreting ptrace stacks and memory */ /* Called once before any other call to ptlib functions */ void ptlib_init(); /* Continue (or detach) a halted process */ int ptlib_continue( int request, pid_t pid, int signal ); /* Called once per new process created */ void ptlib_prepare( pid_t pid ); /* Wait for next event. Returns some data about the event * "status" is the status returned by "wait" * "data" is extra data returned by wait (such as rusage) * "async" is a boolean telling whether to block if we have nothing to report * ptlib_parse_wait parses the info * Reports whether it was a signal delivered at the process (ret gets the signal number) * A process stopped due to signal (ret is the signal number) * A process terminated (ret is the return code) * A process terminated (ret is the signal that killed it) * A SYSCALL took place (ret is the syscall number) * A new process being created (only if PTLIB_SUPPORTS_{FORK,VFORK,CLONE} is defined for the platform) - ret is the new PID */ enum PTLIB_WAIT_RET { SIGNAL, EXIT, SIGEXIT, SYSCALL, NEWPROCESS }; int ptlib_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ); long ptlib_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ); /* If we get a trace before we run ptlib_prepare, we might mis-interpret the signals */ int ptlib_reinterpret( enum PTLIB_WAIT_RET prestate, pid_t pid, int status, long *ret ); /* Returns/sets the Program Counter (EIP on Intel) for the traced program */ void *ptlib_get_pc( pid_t pid ); int ptlib_set_pc( pid_t pid, int_ptr location ); /* Syscall analysis functions - call only when stopped process just invoked a syscall */ /* Report the syscall number being invoked */ int ptlib_get_syscall( pid_t pid ); int ptlib_set_syscall( pid_t pid, int sc_num ); /* Change the meaning of a just started system call */ int ptlib_generate_syscall( pid_t pid, int sc_num, int_ptr base_memory ); /* Generate a new system call */ /* Return the nth argument passed */ int_ptr ptlib_get_argument( pid_t pid, int argnum ); int ptlib_set_argument( pid_t pid, int argnum, int_ptr value ); int_ptr ptlib_get_retval( pid_t pid ); int ptlib_success( pid_t pid, int sc_num ); /* Report whether the syscall succeeded */ void ptlib_set_retval( pid_t pid, int_ptr val ); void ptlib_set_error( pid_t pid, int sc_num, int error ); int ptlib_get_error( pid_t pid, int sc_num ); /* Copy memory in and out of the process * Return TRUE on success */ int ptlib_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ); int ptlib_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ); /* Copy a NULL terminated string. "get" returns the number of bytes copied, including the NULL */ int ptlib_get_string( pid_t pid, int_ptr process_ptr, char *local_ptr, size_t maxlen ); int ptlib_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ); /* Get a process' current directory and open fds */ /* Return value is as for "readlink" */ ssize_t ptlib_get_cwd( pid_t pid, char *buffer, size_t buff_size ); ssize_t ptlib_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ); /* Save/restore the process state */ void ptlib_save_state( pid_t pid, void *buffer ); void ptlib_restore_state( pid_t pid, const void *buffer ); /* Initialize debugger controled memory inside debuggee address space */ const void *ptlib_prepare_memory( ); /* Returns pointer to static buffer with the desired opcods, of ptlib_prepare_memory_len length */ size_t ptlib_prepare_memory_len(); /* How much memory does the platform need beyond how much the process needs */ /* Process relationship - return the parent of a process */ pid_t ptlib_get_parent( pid_t pid ); /* Process creation with debugger attached: * call the "enter" right before the function, "exit" right after it returns * ptlib_fork_enter returns true if it did not change the syscall, false if it did. * orig_sc is the original system call used by the process. * ptlib_fork_exit returns true if a new process was created, false if the call failed. * * Caller should make sure to call ptlib_fork_exit for both child AND parent process. * Keep in mind that child process might start running (traced) before the parent * process returns from the fork, or after. It is also possible that child or parent * will run to completion before the other one returns from the fork. Caller must be * prepared to handle them in arbitrary order. * * The pid of the new process is returned in newpid as per fork's return code (or * whatever function it is that was called). * * ptlib_fork_exit makes sure that the return value from the kernel matches what the * called of fork (or whatever) would expect * process_mem is a pointer to the shared memory area in the process space (as per ptlib_generate_syscall) * our_mem is a pointer to the same memory in the debugger porcess space */ #define FORK_CONTEXT_SIZE 3 int ptlib_fork_enter( pid_t pid, int orig_sc, int_ptr process_mem, void *our_mem, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ); int ptlib_fork_exit( pid_t pid, pid_t *newpid, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ); /* This is a function that must be provided by the user of the library */ void __dlog_( const char *format, ... ) COMPHINT_PRINTF( 1, 2); extern int log_level; #define dlog if( log_level>0 ) __dlog_ #ifdef __cplusplus }; #endif #endif /* PLATFORM_H */ fakeroot-ng-0.18/arch/Makefile.in0000644000175000017500000001720312131751664015045 0ustar sunsun# Makefile.in generated by automake 1.11.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, # 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, # Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ subdir = arch DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = SOURCES = ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ CXXDEPMODE = @CXXDEPMODE@ CXXFLAGS = @CXXFLAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ ac_ct_CXX = @ac_ct_CXX@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ all: all-am .SUFFIXES: $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu arch/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --gnu arch/Makefile .PRECIOUS: Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): tags: TAGS TAGS: ctags: CTAGS CTAGS: check-am: all-am check: check-am all-am: Makefile all-local installdirs: install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ `test -z '$(STRIP)' || \ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic mostlyclean-am distclean: distclean-am -rm -f Makefile distclean-am: clean-am distclean-generic dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: .MAKE: install-am install-strip .PHONY: all all-am all-local check check-am clean clean-generic \ distclean distclean-generic dvi dvi-am html html-am info \ info-am install install-am install-data install-data-am \ install-dvi install-dvi-am install-exec install-exec-am \ install-html install-html-am install-info install-info-am \ install-man install-pdf install-pdf-am install-ps \ install-ps-am install-strip installcheck installcheck-am \ installdirs maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-generic pdf pdf-am ps ps-am uninstall \ uninstall-am all-local: $(MAKE) -C $(target_os)/$(target_cpu) # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: fakeroot-ng-0.18/arch/linux/0000755000175000017500000000000012131751625014131 5ustar sunsunfakeroot-ng-0.18/arch/linux/x86_64/0000755000175000017500000000000012131751625015067 5ustar sunsunfakeroot-ng-0.18/arch/linux/x86_64/platform.c0000644000175000017500000004617511461300537017071 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #define __FRAME_OFFSETS #include #include #include #include "../../platform.h" #include "../os.h" #define mem_offset 8 static const char memory_image[mem_offset]= { 0xcd, 0x80, /* int 0x80 - syscall for 32 bit */ 0x00, 0x00, /* Pad */ 0x0f, 0x05, /* syscall - 64 bit */ 0x00, 0x00, /* Pad */ }; static int syscall_instr64_offset=4; /* All entries stating "-1" mean unimplemented (32bit) function * All entries stating SYS_ instead of __NR_ mean a function unimplemented in 64bit, which we allocate a (fictive) syscall number for */ static int syscall_32_to_64[]={ __NR_restart_syscall, /* 0 */ __NR_exit, /* 1 */ __NR_fork, /* 2 */ __NR_read, /* 3 */ __NR_write, /* 4 */ __NR_open, /* 5 */ __NR_close, /* 6 */ SYS_waitpid, /* 7 */ __NR_creat, /* 8 */ __NR_link, /* 9 */ __NR_unlink, /* 10 */ __NR_execve, /* 11 */ __NR_chdir, /* 12 */ __NR_time, /* 13 */ __NR_mknod, /* 14 */ __NR_chmod, /* 15 */ __NR_lchown, /* 16 */ -1, /* __NR_break, 17 */ SYS_oldstat, /* 18 */ __NR_lseek, /* 19 */ __NR_getpid, /* 20 */ __NR_mount, /* 21 */ -1, /* __NR_umount, 22 */ __NR_setuid, /* 23 */ __NR_getuid, /* 24 */ -1, /* __NR_stime, 25 */ __NR_ptrace, /* 26 */ __NR_alarm, /* 27 */ SYS_oldfstat, /* 28 */ __NR_pause, /* 29 */ __NR_utime, /* 30 */ -1, /* __NR_stty, 31 */ -1, /* __NR_gtty, 32 */ __NR_access, /* 33 */ -1, /* __NR_nice, 34 */ -1, /* __NR_ftime, 35 */ __NR_sync, /* 36 */ __NR_kill, /* 37 */ __NR_rename, /* 38 */ __NR_mkdir, /* 39 */ __NR_rmdir, /* 40 */ __NR_dup, /* 41 */ __NR_pipe, /* 42 */ __NR_times, /* 43 */ -1, /* prof, 44 */ __NR_brk, /* 45 */ __NR_setgid, /* 46 */ __NR_getgid, /* 47 */ -1, /* signal, 48 */ __NR_geteuid, /* 49 */ __NR_getegid, /* 50 */ __NR_acct, /* 51 */ __NR_umount2, /* 52 */ -1, /* lock, 53 */ __NR_ioctl, /* 54 */ __NR_fcntl, /* 55 */ -1, /* mpx, 56 */ __NR_setpgid, /* 57 */ -1, /* ulimit, 58 */ -1, /* oldolduname, 59 */ __NR_umask, /* 60 */ __NR_chroot, /* 61 */ __NR_ustat, /* 62 */ __NR_dup2, /* 63 */ __NR_getppid, /* 64 */ __NR_getpgrp, /* 65 */ __NR_setsid, /* 66 */ -1, /* sigaction, 67 */ -1, /* sgetmask, 68 */ -1, /* ssetmask, 69 */ __NR_setreuid, /* 70 */ __NR_setregid, /* 71 */ -1, /* sigsuspend, 72 */ -1, /* sigpending, 73 */ __NR_sethostname, /* 74 */ __NR_setrlimit, /* 75 */ __NR_getrlimit, /* 76 */ /* Back compatible 2Gig limited rlimit */ __NR_getrusage, /* 77 */ __NR_gettimeofday, /* 78 */ __NR_settimeofday, /* 79 */ __NR_getgroups, /* 80 */ __NR_setgroups, /* 81 */ __NR_select, /* 82 */ __NR_symlink, /* 83 */ SYS_oldlstat, /* 84 */ __NR_readlink, /* 85 */ __NR_uselib, /* 86 */ __NR_swapon, /* 87 */ __NR_reboot, /* 88 */ -1, /* readdir, 89 */ SYS_mmap2, /* 90 */ /* See comment for __NR_mmap (192) */ __NR_munmap, /* 91 */ __NR_truncate, /* 92 */ __NR_ftruncate, /* 93 */ __NR_fchmod, /* 94 */ __NR_fchown, /* 95 */ __NR_getpriority, /* 96 */ __NR_setpriority, /* 97 */ -1, /* profil, 98 */ __NR_statfs, /* 99 */ __NR_fstatfs, /* 100 */ __NR_ioperm, /* 101 */ -1, /* socketcall, 102 */ __NR_syslog, /* 103 */ __NR_setitimer, /* 104 */ __NR_getitimer, /* 105 */ __NR_stat, /* 106 */ __NR_lstat, /* 107 */ __NR_fstat, /* 108 */ -1, /* olduname, 109 */ __NR_iopl, /* 110 */ __NR_vhangup, /* 111 */ -1, /* idle, 112 */ -1, /* vm86old, 113 */ __NR_wait4, /* 114 */ __NR_swapoff, /* 115 */ __NR_sysinfo, /* 116 */ -1, /* ipc, 117 */ __NR_fsync, /* 118 */ SYS_sigreturn, /* 119 */ __NR_clone, /* 120 */ __NR_setdomainname, /* 121 */ __NR_uname, /* 122 */ __NR_modify_ldt, /* 123 */ __NR_adjtimex, /* 124 */ __NR_mprotect, /* 125 */ -1, /* sigprocmask, 126 */ __NR_create_module, /* 127 */ __NR_init_module, /* 128 */ __NR_delete_module, /* 129 */ __NR_get_kernel_syms, /* 130 */ __NR_quotactl, /* 131 */ __NR_getpgid, /* 132 */ __NR_fchdir, /* 133 */ -1, /* bdflush, 134 */ __NR_sysfs, /* 135 */ __NR_personality, /* 136 */ __NR_afs_syscall, /* 137 */ /* Syscall for Andrew File System */ __NR_setfsuid, /* 138 */ __NR_setfsgid, /* 139 */ -1, /* _llseek, 140 */ __NR_getdents, /* 141 */ -1, /* _newselect, 142 */ __NR_flock, /* 143 */ __NR_msync, /* 144 */ __NR_readv, /* 145 */ __NR_writev, /* 146 */ __NR_getsid, /* 147 */ __NR_fdatasync, /* 148 */ __NR__sysctl, /* 149 */ __NR_mlock, /* 150 */ __NR_munlock, /* 151 */ __NR_mlockall, /* 152 */ __NR_munlockall, /* 153 */ __NR_sched_setparam, /* 154 */ __NR_sched_getparam, /* 155 */ __NR_sched_setscheduler, /* 156 */ __NR_sched_getscheduler, /* 157 */ __NR_sched_yield, /* 158 */ __NR_sched_get_priority_max, /* 159 */ __NR_sched_get_priority_min, /* 160 */ __NR_sched_rr_get_interval, /* 161 */ __NR_nanosleep, /* 162 */ __NR_mremap, /* 163 */ __NR_setresuid, /* 164 */ __NR_getresuid, /* 165 */ -1, /* vm86, 166 */ __NR_query_module, /* 167 */ __NR_poll, /* 168 */ __NR_nfsservctl, /* 169 */ __NR_setresgid, /* 170 */ __NR_getresgid, /* 171 */ __NR_prctl, /* 172 */ __NR_rt_sigreturn, /* 173 */ __NR_rt_sigaction, /* 174 */ __NR_rt_sigprocmask, /* 175 */ __NR_rt_sigpending, /* 176 */ __NR_rt_sigtimedwait, /* 177 */ __NR_rt_sigqueueinfo, /* 178 */ __NR_rt_sigsuspend, /* 179 */ __NR_pread64, /* 180 */ __NR_pwrite64, /* 181 */ __NR_chown, /* 182 */ __NR_getcwd, /* 183 */ __NR_capget, /* 184 */ __NR_capset, /* 185 */ __NR_sigaltstack, /* 186 */ __NR_sendfile, /* 187 */ __NR_getpmsg, /* 188 */ /* some people actually want streams */ __NR_putpmsg, /* 189 */ /* some people actually want streams */ __NR_vfork, /* 190 */ -1, /* ugetrlimit, 191 */ /* SuS compliant getrlimit */ __NR_mmap, /* 192 */ /* Technically, this is mmap2. However, it is much more reasonable as far as arguments are handled to map it this way. */ -1, /* truncate64, 193 */ -1, /* ftruncate64, 194 */ SYS_stat64, /* 195 */ SYS_lstat64, /* 196 */ SYS_fstat64, /* 197 */ SYS_lchown32, /* 198 */ SYS_getuid32, /* 199 */ SYS_getgid32, /* 200 */ SYS_geteuid32, /* 201 */ SYS_getegid32, /* 202 */ SYS_setreuid32, /* 203 */ SYS_setregid32, /* 204 */ SYS_getgroups32, /* 205 */ SYS_setgroups32, /* 206 */ SYS_fchown32, /* 207 */ SYS_setresuid32, /* 208 */ SYS_getresuid32, /* 209 */ SYS_setresgid32, /* 210 */ SYS_getresgid32, /* 211 */ SYS_chown32, /* 212 */ SYS_setuid32, /* 213 */ SYS_setgid32, /* 214 */ SYS_setfsuid32, /* 215 */ SYS_setfsgid32, /* 216 */ __NR_pivot_root, /* 217 */ __NR_mincore, /* 218 */ __NR_madvise, /* 219 */ -1, /* __NR_madvise1, 219 */ __NR_getdents64, /* 220 */ -1, /* __NR_fcntl64, 221 */ -1, /* 223 is unused */ __NR_gettid, /* 224 */ __NR_readahead, /* 225 */ __NR_setxattr, /* 226 */ __NR_lsetxattr, /* 227 */ __NR_fsetxattr, /* 228 */ __NR_getxattr, /* 229 */ __NR_lgetxattr, /* 230 */ __NR_fgetxattr, /* 231 */ __NR_listxattr, /* 232 */ __NR_llistxattr, /* 233 */ __NR_flistxattr, /* 234 */ __NR_removexattr, /* 235 */ __NR_lremovexattr, /* 236 */ __NR_fremovexattr, /* 237 */ __NR_tkill, /* 238 */ -1, /* __NR_sendfile64, 239 */ __NR_futex, /* 240 */ __NR_sched_setaffinity, /* 241 */ __NR_sched_getaffinity, /* 242 */ __NR_set_thread_area, /* 243 */ __NR_get_thread_area, /* 244 */ __NR_io_setup, /* 245 */ __NR_io_destroy, /* 246 */ __NR_io_getevents, /* 247 */ __NR_io_submit, /* 248 */ __NR_io_cancel, /* 249 */ __NR_fadvise64, /* 250 */ -1, /* 251 is available for reuse (was briefly sys_set_zone_reclaim) */ __NR_exit_group, /* 252 */ __NR_lookup_dcookie, /* 253 */ __NR_epoll_create, /* 254 */ __NR_epoll_ctl, /* 255 */ __NR_epoll_wait, /* 256 */ __NR_remap_file_pages, /* 257 */ __NR_set_tid_address, /* 258 */ __NR_timer_create, /* 259 */ __NR_timer_settime, /* 260 */ __NR_timer_gettime, /* 261 */ __NR_timer_getoverrun, /* 262 */ __NR_timer_delete, /* 263 */ __NR_clock_settime, /* 264 */ __NR_clock_gettime, /* 265 */ __NR_clock_getres, /* 266 */ __NR_clock_nanosleep, /* 267 */ -1, /* statfs64, 268 */ -1, /* fstatfs64, 269 */ __NR_tgkill, /* 270 */ __NR_utimes, /* 271 */ -1, /* fadvise64_64, 272 */ __NR_vserver, /* 273 */ __NR_mbind, /* 274 */ __NR_get_mempolicy, /* 275 */ __NR_set_mempolicy, /* 276 */ __NR_mq_open, /* 277 */ __NR_mq_unlink, /* 278 */ __NR_mq_timedsend, /* 279 */ __NR_mq_timedreceive, /* 280 */ __NR_mq_notify, /* 281 */ __NR_mq_getsetattr, /* 282 */ __NR_kexec_load, /* 283 */ __NR_waitid, /* 284 */ -1, /* __NR_sys_setaltroot 285 */ __NR_add_key, /* 286 */ __NR_request_key, /* 287 */ __NR_keyctl, /* 288 */ __NR_ioprio_set, /* 289 */ __NR_ioprio_get, /* 290 */ __NR_inotify_init, /* 291 */ __NR_inotify_add_watch, /* 292 */ __NR_inotify_rm_watch, /* 293 */ __NR_migrate_pages, /* 294 */ __NR_openat, /* 295 */ __NR_mkdirat, /* 296 */ __NR_mknodat, /* 297 */ __NR_fchownat, /* 298 */ __NR_futimesat, /* 299 */ SYS_fstatat64, /* 300 */ __NR_unlinkat, /* 301 */ __NR_renameat, /* 302 */ __NR_linkat, /* 303 */ __NR_symlinkat, /* 304 */ __NR_readlinkat, /* 305 */ __NR_fchmodat, /* 306 */ __NR_faccessat, /* 307 */ __NR_pselect6, /* 308 */ __NR_ppoll, /* 309 */ __NR_unshare, /* 310 */ __NR_set_robust_list, /* 311 */ __NR_get_robust_list, /* 312 */ __NR_splice, /* 313 */ __NR_sync_file_range, /* 314 */ __NR_tee, /* 315 */ __NR_vmsplice, /* 316 */ __NR_move_pages, /* 317 */ -1, /* getcpu, 318 */ -1, /* epoll_pwait, 319 */ -1, /* utimensat, 320 */ -1, /* __NR_signalfd, 321 */ -1, /* __NR_timerfd, 322 */ -1, /* __NR_eventfd, 323 */ }; #define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0])) #define MAP_SIZE_32_64 (ARRAY_SIZE(syscall_32_to_64)+SYS_X86_32_OFFSET) static int syscall_64_to_32[MAP_SIZE_32_64]; /* We init the reverse map when the library loads */ void ptlib_init() { unsigned int i; for( i=0; i=(-SYS_X86_32_OFFSET) && syscall_32_to_64[i]<(int)ARRAY_SIZE(syscall_32_to_64) ) { syscall_64_to_32[syscall_32_to_64[i]+SYS_X86_32_OFFSET]=i; } } } static pid_t cache_process; static int cache_64; /* Is the process 64 bit? */ static int is_64( pid_t pid ) { if( cache_process!=pid ) { unsigned long cs=ptrace( PTRACE_PEEKUSER, pid, CS, 0 ); cache_process=pid; switch(cs) { case 0x33: cache_64=1; // 64 bit mode break; case 0x23: cache_64=0; // 32 bit mode break; default: dlog("is_64: "PID_F" unknown usbsystem 0x%lx\n", pid, cs ); break; } } return cache_64; } int ptlib_continue( int request, pid_t pid, int signal ) { /* Invalidate the cache */ cache_process=0; return ptlib_linux_continue( request, pid, signal ); } void ptlib_prepare( pid_t pid ) { ptlib_linux_prepare(pid); } int ptlib_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ) { return ptlib_linux_wait( pid, status, data, async ); } long ptlib_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ) { return ptlib_linux_parse_wait( pid, status, type ); } int ptlib_reinterpret( enum PTLIB_WAIT_RET prestate, pid_t pid, int status, long *ret ) { return ptlib_linux_reinterpret( prestate, pid, status, ret ); } void *ptlib_get_pc( pid_t pid ) { return (void *)ptrace( PTRACE_PEEKUSER, pid, RIP, 0 ); } int ptlib_set_pc( pid_t pid, int_ptr location ) { return ptrace( PTRACE_POKEUSER, pid, RIP, location ); } int ptlib_get_syscall( pid_t pid ) { int syscall=ptrace( PTRACE_PEEKUSER, pid, ORIG_RAX, 0 ); // Need to translate the 32 bit syscalls to 64 bit ones if( !is_64(pid) ) { if( syscall>=0 && (unsigned int)syscall=0 && (unsigned int)sc6 ) { dlog("ptlib_get_argument: "PID_F" invalid argument number %d\n", pid, argnum); errno=EINVAL; return -1; } if( is_64(pid) ) { /* 64 bit */ return ptrace( PTRACE_PEEKUSER, pid, arg_offset_64bit[argnum-1], 0 ); } else { /* 32 bit */ return ptrace( PTRACE_PEEKUSER, pid, arg_offset_32bit[argnum-1], 0 ); } } int ptlib_set_argument( pid_t pid, int argnum, int_ptr value ) { if( argnum<1 || argnum>6 ) { dlog("ptlib_set_argument: "PID_F" invalid argument number %d\n", pid, argnum); errno=EINVAL; return -1; } if( is_64(pid) ) { /* 64 bit */ return ptrace( PTRACE_POKEUSER, pid, arg_offset_64bit[argnum-1], value ); } else { /* 32 bit */ return ptrace( PTRACE_POKEUSER, pid, arg_offset_32bit[argnum-1], value ); } } int_ptr ptlib_get_retval( pid_t pid ) { return ptrace( PTRACE_PEEKUSER, pid, RAX ); } int ptlib_success( pid_t pid, int sc_num ) { unsigned long ret=ptlib_get_retval( pid ); /* This heuristic is good for all syscalls we found. It may not be good for all of them */ return ret<0xfffffffffffff000u; #if 0 switch( sc_num ) { case SYS_mmap: case SYS_mmap2: /* -errno on error */ return ((unsigned int)ret)<0xfffff000u; default: return ((int)ret)>=0; } #endif } void ptlib_set_retval( pid_t pid, int_ptr val ) { ptrace( PTRACE_POKEUSER, pid, RAX, val ); } void ptlib_set_error( pid_t pid, int sc_num, int error ) { ptlib_set_retval( pid, -error ); } int ptlib_get_error( pid_t pid, int sc_num ) { return -(long)ptlib_get_retval( pid ); } int ptlib_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ) { return ptlib_linux_get_mem( pid, process_ptr, local_ptr, len ); } int ptlib_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ) { return ptlib_linux_set_mem( pid, local_ptr, process_ptr, len ); } int ptlib_get_string( pid_t pid, int_ptr process_ptr, char *local_ptr, size_t maxlen ) { return ptlib_linux_get_string( pid, process_ptr, local_ptr, maxlen ); } int ptlib_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ) { return ptlib_linux_set_string( pid, local_ptr, process_ptr ); } ssize_t ptlib_get_cwd( pid_t pid, char *buffer, size_t buff_size ) { return ptlib_linux_get_cwd( pid, buffer, buff_size ); } ssize_t ptlib_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ) { return ptlib_linux_get_fd( pid, fd, buffer, buff_size ); } void ptlib_save_state( pid_t pid, void *buffer ) { ptrace( PTRACE_GETREGS, pid, 0, buffer ); } void ptlib_restore_state( pid_t pid, const void *buffer ) { ptrace( PTRACE_SETREGS, pid, 0, buffer ); } const void *ptlib_prepare_memory( ) { return memory_image; } size_t ptlib_prepare_memory_len() { return mem_offset; } pid_t ptlib_get_parent( pid_t pid ) { return ptlib_linux_get_parent(pid); } int ptlib_fork_enter( pid_t pid, int orig_sc, int_ptr process_mem, void *our_mem, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { return ptlib_linux_fork_enter( pid, orig_sc, process_mem, our_mem, registers, context ); } int ptlib_fork_exit( pid_t pid, pid_t *newpid, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { return ptlib_linux_fork_exit( pid, newpid, registers, context ); } fakeroot-ng-0.18/arch/linux/x86_64/platform_specific.h0000644000175000017500000000701111204416527020727 0ustar sunsun#ifndef PLATFORM_SPECIFIC_H #define PLATFORM_SPECIFIC_H #include #include #include /* Specially defined 32 bit syscalls that don't have a 64 syscall, but need to be handled */ #define __NR_waitpid -3 #define SYS_waitpid __NR_waitpid #define __NR_oldstat -4 #define SYS_oldstat __NR_oldstat #define __NR_oldfstat -5 #define SYS_oldfstat __NR_oldfstat #define __NR_oldlstat -6 #define SYS_oldlstat __NR_oldlstat #define __NR_sigreturn -7 #define SYS_sigreturn __NR_sigreturn #define __NR_mmap2 -8 #define SYS_mmap2 __NR_mmap2 #define __NR_stat64 -9 #define SYS_stat64 __NR_stat64 #define __NR_lstat64 -10 #define SYS_lstat64 __NR_lstat64 #define __NR_fstat64 -11 #define SYS_fstat64 __NR_fstat64 #define __NR_lchown32 -12 #define SYS_lchown32 __NR_lchown32 #define __NR_getuid32 -13 #define SYS_getuid32 __NR_getuid32 #define __NR_getgid32 -14 #define SYS_getgid32 __NR_getgid32 #define __NR_geteuid32 -15 #define SYS_geteuid32 __NR_geteuid32 #define __NR_getegid32 -16 #define SYS_getegid32 __NR_getegid32 #define __NR_setreuid32 -17 #define SYS_setreuid32 __NR_setreuid32 #define __NR_setregid32 -18 #define SYS_setregid32 __NR_setregid32 #define __NR_getgroups32 -19 #define SYS_getgroups32 __NR_getgroups32 #define __NR_setgroups32 -20 #define SYS_setgroups32 __NR_setgroups32 #define __NR_fchown32 -21 #define SYS_fchown32 __NR_fchown32 #define __NR_setresuid32 -22 #define SYS_setresuid32 __NR_setresuid32 #define __NR_getresuid32 -23 #define SYS_getresuid32 __NR_getresuid32 #define __NR_setresgid32 -24 #define SYS_setresgid32 __NR_setresgid32 #define __NR_getresgid32 -25 #define SYS_getresgid32 __NR_getresgid32 #define __NR_chown32 -26 #define SYS_chown32 __NR_chown32 #define __NR_setuid32 -27 #define SYS_setuid32 __NR_setuid32 #define __NR_setgid32 -28 #define SYS_setgid32 __NR_setgid32 #define __NR_setfsuid32 -29 #define SYS_setfsuid32 __NR_setfsuid32 #define __NR_setfsgid32 -30 #define SYS_setfsgid32 __NR_setfsgid32 #define __NR_fstatat64 -31 #define SYS_fstatat64 __NR_fstatat64 #define SYS_X86_32_OFFSET 31 /* Marks the library as supporting debugging children */ #define PTLIB_SUPPORTS_FORK 1 #define PTLIB_SUPPORTS_VFORK 1 #define PTLIB_SUPPORTS_CLONE 1 #define PTLIB_PARENT_CAN_WAIT 1 #define PTLIB_STATE_SIZE (27) /* This is defined to 1 if the platform sends a SIGTRAP to the process after a successful execve if it's being traced */ #define PTLIB_TRAP_AFTER_EXEC 1 typedef unsigned long ptlib_inode_t; struct ptlib_stat { unsigned long dev; unsigned long ino; unsigned long nlink; unsigned int mode; unsigned int uid; unsigned int gid; unsigned int __pad0; unsigned long rdev; long size; long blksize; long blocks; /* Number 512-byte blocks allocated. */ unsigned long atime; unsigned long atime_nsec; unsigned long mtime; unsigned long mtime_nsec; unsigned long ctime; unsigned long ctime_nsec; long __unused[3]; }; typedef struct rusage ptlib_extra_data; /* Platform specific format specifiers for printing pid, dev and inode */ #define PID_F "%d" #define DEV_F "%lx" #define INODE_F "%ld" #define UID_F "%u" #define GID_F "%u" /* Preferred stat functions to use */ #define PREF_STAT SYS_stat #define PREF_LSTAT SYS_lstat #define PREF_FSTAT SYS_fstat #define PREF_FSTATAT SYS_newfstatat #define PREF_NOP SYS_getuid #define PREF_MMAP SYS_mmap /* An unsigned int as long as a pointer */ typedef unsigned long int_ptr; #endif /* PLATFORM_SPECIFIC_H */ fakeroot-ng-0.18/arch/linux/x86_64/Makefile.in0000644000175000017500000000010611052760654017134 0ustar sunsun libarch_a_OBJECTS=platform.lo ../os.lo include ../Makefile.template fakeroot-ng-0.18/arch/linux/i386/0000755000175000017500000000000012131751625014622 5ustar sunsunfakeroot-ng-0.18/arch/linux/i386/platform.c0000644000175000017500000001246311461300537016615 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include "../../platform.h" #include "../os.h" #define mem_offset 8 static const char memory_image[mem_offset]= { 0xcd, 0x80, /* int 0x80 - syscall */ 0x00, 0x00, /* Pad */ }; void ptlib_init() { // Nothing to be done on this platform } int ptlib_continue( int request, pid_t pid, int signal ) { return ptlib_linux_continue( request, pid, signal ); } const void *ptlib_prepare_memory( ) { return memory_image; } size_t ptlib_prepare_memory_len() { return mem_offset; } void ptlib_prepare( pid_t pid ) { ptlib_linux_prepare( pid ); } int ptlib_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ) { return ptlib_linux_wait( pid, status, data, async ); } long ptlib_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ) { return ptlib_linux_parse_wait( pid, status, type ); } int ptlib_get_syscall( pid_t pid ) { return ptrace( PTRACE_PEEKUSER, pid, 4*ORIG_EAX, 0 ); } int ptlib_set_syscall( pid_t pid, int sc_num ) { return ptrace( PTRACE_POKEUSER, pid, 4*ORIG_EAX, sc_num ); } int ptlib_generate_syscall( pid_t pid, int sc_num, int_ptr base_memory ) { /* Cannot generate a syscall per-se. Instead, set program counter to an instruction known to generate one */ ptrace( PTRACE_POKEUSER, pid, 4*EAX, sc_num ); ptrace( PTRACE_POKEUSER, pid, 4*EIP, base_memory-mem_offset ); return 1; } int_ptr ptlib_get_argument( pid_t pid, int argnum ) { if( argnum<6 && argnum>0 ) return ptrace( PTRACE_PEEKUSER, pid, 4*(argnum-1), 0 ); /* Illegal arg num */ dlog("ptlib_get_argument: "PID_F" Illegal argnum %d was asked for\n", pid, argnum ); errno=EINVAL; return -1; } int ptlib_set_argument( pid_t pid, int argnum, int_ptr value ) { if( argnum<=6 && argnum>0 ) return ptrace( PTRACE_POKEUSER, pid, 4*(argnum-1), value )==0; /* Illegal arg num */ dlog("ptlib_set_argument: "PID_F" Illegal argnum %d was asked for\n", pid, argnum ); errno=EINVAL; return -1; } int_ptr ptlib_get_retval( pid_t pid ) { return ptrace( PTRACE_PEEKUSER, pid, 4*EAX ); } void ptlib_set_retval( pid_t pid, int_ptr val ) { ptrace( PTRACE_POKEUSER, pid, 4*EAX, val ); } int ptlib_get_error( pid_t pid, int sc_num ) { return -(int)ptlib_get_retval( pid ); } void ptlib_set_error( pid_t pid, int sc_num, int error ) { ptlib_set_retval( pid, -error ); } int ptlib_success( pid_t pid, int sc_num ) { int ret=ptlib_get_retval( pid ); switch( sc_num ) { case SYS_mmap: case SYS_mmap2: /* -errno on error */ return ((unsigned int)ret)<0xfffff000u; default: return ret>=0; } } int ptlib_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ) { return ptlib_linux_get_mem( pid, process_ptr, local_ptr, len ); } int ptlib_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ) { return ptlib_linux_set_mem( pid, local_ptr, process_ptr, len ); } void ptlib_save_state( pid_t pid, void *buffer ) { ptrace( PTRACE_GETREGS, pid, 0, buffer ); } void ptlib_restore_state( pid_t pid, const void *buffer ) { ptrace( PTRACE_SETREGS, pid, 0, buffer ); } int ptlib_get_string( pid_t pid, int_ptr process_ptr, char *local_ptr, size_t maxlen ) { return ptlib_linux_get_string( pid, process_ptr, local_ptr, maxlen ); } int ptlib_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ) { return ptlib_linux_set_string( pid, local_ptr, process_ptr ); } ssize_t ptlib_get_cwd( pid_t pid, char *buffer, size_t buff_size ) { return ptlib_linux_get_cwd( pid, buffer, buff_size ); } ssize_t ptlib_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ) { return ptlib_linux_get_fd( pid, fd, buffer, buff_size ); } pid_t ptlib_get_parent( pid_t pid ) { return ptlib_linux_get_parent(pid); } int ptlib_fork_enter( pid_t pid, int orig_sc, int_ptr process_mem, void *our_mem, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { return ptlib_linux_fork_enter( pid, orig_sc, process_mem, our_mem, registers, context ); } int ptlib_fork_exit( pid_t pid, pid_t *newpid, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { return ptlib_linux_fork_exit( pid, newpid, registers, context ); } fakeroot-ng-0.18/arch/linux/i386/platform_specific.h0000644000175000017500000000350511051473777020500 0ustar sunsun#ifndef PLATFORM_SPECIFIC_H #define PLATFORM_SPECIFIC_H #include #include #include /* Marks the library as supporting debugging children */ #define PTLIB_SUPPORTS_FORK 1 #define PTLIB_SUPPORTS_VFORK 1 #define PTLIB_SUPPORTS_CLONE 1 #define PTLIB_PARENT_CAN_WAIT 1 #define PTLIB_STATE_SIZE (FRAME_SIZE) /* This is defined to 1 if the platform sends a SIGTRAP to the process after a successful execve if it's being traced */ #define PTLIB_TRAP_AFTER_EXEC 1 typedef unsigned long long ptlib_inode_t; struct ptlib_stat { unsigned long long dev; unsigned char __pad0[4]; #define STAT64_HAS_BROKEN_ST_INO 1 unsigned long __ino; unsigned int mode; unsigned int nlink; unsigned long uid; unsigned long gid; unsigned long long rdev; unsigned char __pad3[4]; long long size; unsigned long blksize; unsigned long long blocks; /* Number 512-byte blocks allocated. */ unsigned long atime; unsigned long atime_nsec; unsigned long mtime; unsigned int mtime_nsec; unsigned long ctime; unsigned long ctime_nsec; unsigned long long ino; }; typedef struct rusage ptlib_extra_data; /* Platform specific format specifiers for printing pid, dev and inode */ #define PID_F "%d" #define DEV_F "%llx" #define INODE_F "%lld" #define UID_F "%lu" #define GID_F "%lu" /* Preferred stat functions to use */ #define PREF_STAT SYS_stat64 #define PREF_LSTAT SYS_lstat64 #define PREF_FSTAT SYS_fstat64 #define PREF_FSTATAT SYS_fstatat64 #define PREF_NOP SYS_geteuid32 #define PREF_MMAP SYS_mmap2 /* An unsigned int as long as a pointer */ typedef unsigned long int_ptr; #endif /* PLATFORM_SPECIFIC_H */ fakeroot-ng-0.18/arch/linux/i386/Makefile.in0000644000175000017500000000010611047027253016662 0ustar sunsun libarch_a_OBJECTS=platform.lo ../os.lo include ../Makefile.template fakeroot-ng-0.18/arch/linux/os.c0000644000175000017500000002257012115635163014724 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "../platform.h" #include "os.h" int ptlib_linux_continue( int request, pid_t pid, int signal ) { return ptrace( request, pid, 0, signal ); } void ptlib_linux_prepare( pid_t pid ) { // These cause more harm than good //if( ptrace(PTRACE_SETOPTIONS, pid, 0, PTRACE_O_TRACEFORK|PTRACE_O_TRACEVFORK|PTRACE_O_TRACECLONE)!=0 ) // perror("PTRACE_SETOPTIONS failed"); } int ptlib_linux_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ) { *pid=wait4(-1, status, (async?WNOHANG:0)|__WALL, data ); if( async && *pid==0 ) { errno=EAGAIN; *pid=-1; } return *pid!=-1; } long ptlib_linux_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ) { long ret; if( WIFEXITED(status) ) { ret=WEXITSTATUS(status); *type=EXIT; } else if( WIFSIGNALED(status) ) { ret=WTERMSIG(status); *type=SIGEXIT; } else if( WIFSTOPPED(status) ) { ret=WSTOPSIG(status); if( ret==SIGTRAP ) { siginfo_t siginfo; if( ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo)==0 && (siginfo.si_code>>8==PTRACE_EVENT_FORK || siginfo.si_code>>8==PTRACE_EVENT_VFORK || siginfo.si_code>>8==PTRACE_EVENT_CLONE ) ) { ptrace( PTRACE_GETEVENTMSG, pid, NULL, &ret ); *type=NEWPROCESS; } else { /* Since we cannot reliably know when PTRACE_O_TRACESYSGOOD is supported, we always assume that's the reason for a * SIGTRACE */ ret=ptlib_get_syscall(pid); *type=SYSCALL; } } else { dlog("stopped with some other signal\n"); *type=SIGNAL; } } else { /* What is going on here? We should never get here. */ dlog("Process %d received unknown status %x - aborting\n", pid, status); dlog(NULL); /* Flush the log before we abort */ abort(); } return ret; } int ptlib_linux_reinterpret( enum PTLIB_WAIT_RET prevstate, pid_t pid, int status, long *ret ) { // Previous state does not affect us // XXX if the first thing the child does is a "fork", is this statement still true? return prevstate; } int ptlib_linux_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ) { errno=0; size_t offset=((int_ptr)process_ptr)%sizeof(long); process_ptr-=offset; char *dst=(char *)local_ptr; long buffer=ptrace(PTRACE_PEEKDATA, pid, process_ptr, 0); if( buffer==-1 && errno!=0 ) return 0; // false means failure while( len>0 ) { // XXX Theoretically we can make the write faster by writing it whole "long" at a time. This, of course, requires that // the alignment be correct on the receiving side as well as the sending side, which isn't trivial. // For the time being, this approach is, at least, system call efficient, so we keep it. *dst=((const char *)&buffer)[offset]; offset++; dst++; len--; if( len>0 && offset==sizeof(long) ) { process_ptr+=offset; offset=0; buffer=ptrace(PTRACE_PEEKDATA, pid, process_ptr, 0); if( buffer==-1 && errno!=0 ) return 0; // false means failure } } return errno==0; } int ptlib_linux_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ) { long buffer; size_t offset=((int_ptr)process_ptr)%sizeof(long); process_ptr-=offset; // Make the process PTR aligned errno=0; if( offset!=0 ) { // We have "Stuff" hanging before the area we need to fill - initialize the buffer buffer=ptrace( PTRACE_PEEKDATA, pid, process_ptr, 0 ); } const char *src=local_ptr; while( len>0 && errno==0 ) { ((char *)&buffer)[offset]=*src; src++; offset++; len--; if( offset==sizeof(long) ) { ptrace(PTRACE_POKEDATA, pid, process_ptr, buffer); process_ptr+=offset; offset=0; } } if( errno==0 && offset!=0 ) { // We have leftover data we still need to transfer. Need to make sure we are not // overwriting data outside of our intended area long buffer2=ptrace( PTRACE_PEEKDATA, pid, process_ptr, 0 ); unsigned int i; for( i=offset; i=maxlen; } return i; } int ptlib_linux_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ) { size_t len=strlen(local_ptr)+1; return ptlib_set_mem( pid, local_ptr, process_ptr, len ); } ssize_t ptlib_linux_get_cwd( pid_t pid, char *buffer, size_t buff_size ) { char tmpbuff[20]; /* Leave enough chars for the digits */ sprintf(tmpbuff, "/proc/"PID_F"/cwd", pid ); ssize_t ret=readlink( tmpbuff, buffer, buff_size>0 ? buff_size-1 : 0 ); if( ret>0 ) buffer[ret]='\0'; return ret; } ssize_t ptlib_linux_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ) { char tmpbuff[40]; sprintf(tmpbuff, "/proc/"PID_F"/fd/%d", pid, fd ); ssize_t ret=readlink( tmpbuff, buffer, buff_size>0 ? buff_size-1 : 0 ); if( ret>0 ) buffer[ret]='\0'; return ret; } pid_t ptlib_linux_get_parent( pid_t pid ) { /* Query the proc filesystem to figure out who the process' parent is */ char filename[100]; sprintf(filename, "/proc/"PID_F"/status", pid); FILE *stat_file=fopen(filename, "r"); if( stat_file==NULL ) { dlog("%s: Failed to open %s: %s\n", __FUNCTION__, filename, strerror(errno) ); return -1; } pid_t ret=-1; while( !feof(stat_file) && ret==-1 ) { char line[400]; fgets(line, sizeof(line), stat_file ); /* If this was not the whole line, consume the rest of it */ if( line[strlen(line)-1]!='\n' ) { int ch; while( (ch=getc( stat_file ))!=EOF && ch!='\n' ) ; } if( sscanf( line, "PPid: "PID_F, &ret)!=1 ) ret=-1; } fclose(stat_file); return ret; } int ptlib_linux_fork_enter( pid_t pid, int orig_sc, int_ptr process_mem, void *our_mem, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { /* Turn the fork/vfork into a clone */ int clone_flags=CLONE_PTRACE|SIGCHLD; if( orig_sc==SYS_vfork ) { clone_flags|=CLONE_VFORK|CLONE_VM; } // Store a copy of the arguments we change, in case they held something important int_ptr *save_state=(int_ptr *)registers; save_state[0]=ptlib_get_syscall( pid ); save_state[1]=ptlib_get_argument( pid, 1 ); save_state[2]=ptlib_get_argument( pid, 2 ); ptlib_set_syscall( pid, SYS_clone ); ptlib_set_argument( pid, 1, clone_flags ); /* Flags */ ptlib_set_argument( pid, 2, 0 ); /* Stack base (keep the same) */ /* We did change the system call in use */ return 0; } int ptlib_linux_fork_exit( pid_t pid, pid_t *newpid, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ) { int ret=0; if( ptlib_success( pid, SYS_clone ) ) { ret=1; *newpid=ptlib_get_retval( pid ); } /* Restore the clobbered registers */ const int_ptr *save_state=(const int_ptr *)registers; ptlib_set_syscall( pid, save_state[0] ); ptlib_set_argument( pid, 1, save_state[1] ); ptlib_set_argument( pid, 2, save_state[2] ); return ret; } fakeroot-ng-0.18/arch/linux/powerpc/0000755000175000017500000000000012131751625015610 5ustar sunsunfakeroot-ng-0.18/arch/linux/powerpc/platform.c0000644000175000017500000001332311461300537017577 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include "../../platform.h" #include "../os.h" #define mem_offset 8 static const char memory_image[mem_offset]= { 0x44, 0x00, 0x00, 0x02, /* sc */ }; void ptlib_init() { // Nothing to be done on this platform } int ptlib_continue( int request, pid_t pid, int signal ) { return ptlib_linux_continue( request, pid, signal ); } const void *ptlib_prepare_memory( ) { return memory_image; } size_t ptlib_prepare_memory_len() { return mem_offset; } void ptlib_prepare( pid_t pid ) { ptlib_linux_prepare( pid ); } int ptlib_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ) { return ptlib_linux_wait( pid, status, data, async ); } long ptlib_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ) { return ptlib_linux_parse_wait( pid, status, type ); } int ptlib_get_syscall( pid_t pid ) { return ptrace( PTRACE_PEEKUSER, pid, 4*PT_R0, 0 ); } int ptlib_set_syscall( pid_t pid, int sc_num ) { return ptrace( PTRACE_POKEUSER, pid, 4*PT_R0, sc_num ); } int ptlib_generate_syscall( pid_t pid, int sc_num, int_ptr base_memory ) { /* Cannot generate a syscall per-se. Instead, set program counter to an instruction known to generate one */ ptrace( PTRACE_POKEUSER, pid, 4*PT_R0, sc_num ); ptrace( PTRACE_POKEUSER, pid, 4*PT_NIP, base_memory-mem_offset ); return 1; } int_ptr ptlib_get_argument( pid_t pid, int argnum ) { if( argnum<6 && argnum>0 ) return ptrace( PTRACE_PEEKUSER, pid, 4*(PT_R3+argnum-1), 0 ); /* Illegal arg num */ dlog("ptlib_get_argument: "PID_F" Illegal argnum %d was asked for\n", pid, argnum ); errno=EINVAL; return -1; } int ptlib_set_argument( pid_t pid, int argnum, int_ptr value ) { if( argnum<=6 && argnum>0 ) return ptrace( PTRACE_POKEUSER, pid, 4*(PT_R3+argnum-1), value )==0; /* Illegal arg num */ dlog("ptlib_set_argument: "PID_F" Illegal argnum %d was asked for\n", pid, argnum ); errno=EINVAL; return -1; } int_ptr ptlib_get_retval( pid_t pid ) { return ptrace( PTRACE_PEEKUSER, pid, 4*PT_R3 ); } #define SO_MASK 0x10000000 void ptlib_set_retval( pid_t pid, int_ptr val ) { // Clear SO so we register success unsigned long cr=ptrace( PTRACE_PEEKUSER, pid, PT_CCR*4, 0 ); cr&=~SO_MASK; ptrace( PTRACE_POKEUSER, pid, PT_CCR*4, cr ); ptrace( PTRACE_POKEUSER, pid, 4*PT_R3, val ); } int ptlib_get_error( pid_t pid, int sc_num ) { return (int)ptlib_get_retval( pid ); } void ptlib_set_error( pid_t pid, int sc_num, int val ) { unsigned long cr=ptrace( PTRACE_PEEKUSER, pid, PT_CCR*4, 0 ); cr|=SO_MASK; ptrace( PTRACE_POKEUSER, pid, PT_CCR*4, cr ); ptrace( PTRACE_POKEUSER, pid, 4*PT_R3, val ); } int ptlib_success( pid_t pid, int sc_num ) { /* PowerPC sets the Summary Overflow upon error */ unsigned long cr=ptrace( PTRACE_PEEKUSER, pid, PT_CCR*4, 0 ); return (cr&SO_MASK)==0; } int ptlib_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ) { return ptlib_linux_get_mem( pid, process_ptr, local_ptr, len ); } int ptlib_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ) { return ptlib_linux_set_mem( pid, local_ptr, process_ptr, len ); } int ptlib_get_string( pid_t pid, int_ptr process_ptr, char *local_ptr, size_t maxlen ) { return ptlib_linux_get_string( pid, process_ptr, local_ptr, maxlen ); } int ptlib_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ) { return ptlib_linux_set_string( pid, local_ptr, process_ptr ); } ssize_t ptlib_get_cwd( pid_t pid, char *buffer, size_t buff_size ) { return ptlib_linux_get_cwd( pid, buffer, buff_size ); } ssize_t ptlib_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ) { return ptlib_linux_get_fd( pid, fd, buffer, buff_size ); } void ptlib_save_state( pid_t pid, void *buffer ) { int i; for( i=0; i #include #include /* Marks the library as supporting debugging children */ #define PTLIB_SUPPORTS_FORK 1 #define PTLIB_SUPPORTS_VFORK 1 #define PTLIB_SUPPORTS_CLONE 1 #define PTLIB_PARENT_CAN_WAIT 1 #define PTLIB_STATE_SIZE 50 /* This is defined to 1 if the platform sends a SIGTRAP to the process after a successful execve if it's being traced */ #define PTLIB_TRAP_AFTER_EXEC 1 typedef unsigned long long ptlib_inode_t; struct ptlib_stat { unsigned long long dev; /* Device. */ unsigned long long ino; /* File serial number. */ unsigned int mode; /* File mode. */ unsigned int nlink; /* Link count. */ unsigned int uid; /* User ID of the file's owner. */ unsigned int gid; /* Group ID of the file's group. */ unsigned long long rdev; /* Device number, if device. */ unsigned short __pad2; long long size; /* Size of file, in bytes. */ int blksize; /* Optimal block size for I/O. */ long long blocks; /* Number 512-byte blocks allocated. */ int atime; /* Time of last access. */ unsigned int atime_nsec; int mtime; /* Time of last modification. */ unsigned int mtime_nsec; int ctime; /* Time of last status change. */ unsigned int ctime_nsec; unsigned int __unused4; unsigned int __unused5; }; typedef struct rusage ptlib_extra_data; /* Platform specific format specifiers for printing pid, dev and inode */ #define PID_F "%d" #define DEV_F "%llx" #define INODE_F "%lld" #define UID_F "%lu" #define GID_F "%lu" /* Preferred syscalls to perform certain actions */ #define PREF_STAT SYS_stat64 #define PREF_FSTAT SYS_fstat64 #define PREF_LSTAT SYS_lstat64 #define PREF_FSTATAT SYS_fstatat64 #define PREF_NOP SYS_geteuid #define PREF_MMAP SYS_mmap2 /* An unsigned int as long as a pointer */ typedef unsigned long int_ptr; #endif /* PLATFORM_SPECIFIC_H */ fakeroot-ng-0.18/arch/linux/powerpc/Makefile.in0000644000175000017500000000010611052760654017655 0ustar sunsun libarch_a_OBJECTS=platform.lo ../os.lo include ../Makefile.template fakeroot-ng-0.18/arch/linux/os.h0000644000175000017500000000257011461300537014724 0ustar sunsun#ifndef ARCH_OS_H #define ARCH_OS_H int ptlib_linux_continue( int request, pid_t pid, int signal ); void ptlib_linux_prepare( pid_t pid ); int ptlib_linux_wait( pid_t *pid, int *status, ptlib_extra_data *data, int async ); long ptlib_linux_parse_wait( pid_t pid, int status, enum PTLIB_WAIT_RET *type ); int ptlib_linux_reinterpret( enum PTLIB_WAIT_RET prevstate, pid_t pid, int status, long *ret ); int ptlib_linux_get_mem( pid_t pid, int_ptr process_ptr, void *local_ptr, size_t len ); int ptlib_linux_set_mem( pid_t pid, const void *local_ptr, int_ptr process_ptr, size_t len ); int ptlib_linux_get_string( pid_t pid, int_ptr process_ptr, char *local_ptr, size_t maxlen ); int ptlib_linux_set_string( pid_t pid, const char *local_ptr, int_ptr process_ptr ); ssize_t ptlib_linux_get_cwd( pid_t pid, char *buffer, size_t buff_size ); ssize_t ptlib_linux_get_fd( pid_t pid, int fd, char *buffer, size_t buff_size ); void ptlib_linux_save_state( pid_t pid, void *buffer ); void ptlib_linux_restore_state( pid_t pid, const void *buffer ); pid_t ptlib_linux_get_parent( pid_t pid ); int ptlib_linux_fork_enter( pid_t pid, int orig_sc, int_ptr process_mem, void *our_mem, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ); int ptlib_linux_fork_exit( pid_t pid, pid_t *newpid, void *registers[PTLIB_STATE_SIZE], int_ptr context[FORK_CONTEXT_SIZE] ); #endif /* ARCH_OS_H */ fakeroot-ng-0.18/arch/linux/Makefile.template.in0000644000175000017500000000215411052760654020015 0ustar sunsun libarch.a: $(libarch_a_OBJECTS) $(libarch_a_DEPENDENCIES) $(AR) cru $@.tmp $(libarch_a_OBJECTS) $(RANLIB) $@.tmp mv $@.tmp $@ @SET_MAKE@ VPATH=$(top_srcdir)/arch/$(target_os)/$(target_cpu) CC = @CC@ CCLD = $(CC) DEFS = @DEFS@ CFLAGS = @CFLAGS@ CPPFLAGS = @CPPFLAGS@ DEFAULT_INCLUDES = -I$(top_builddir) -I$(top_srcdir)/arch -I$(top_srcdir)/arch/$(target_os)/$(target_cpu) DEPDIR = @DEPDIR@ RANLIB = @RANLIB@ target_cpu = @target_cpu@ target_os = @target_os@ # Because we are extracted by configure one directory above the one from which we are included, # manually add a "directory up" top_builddir = ../@top_builddir@ top_srcdir = ../@top_srcdir@ %.lo: %.c $(DEPDIR)/stamp $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) \ -MT $@ -MD -MP -MF $(DEPDIR)/$(notdir $*.Tdep) -c -o $@ $< mv -f $(DEPDIR)/$(notdir $*.Tdep) $(DEPDIR)/$(notdir $*.dep) $(DEPDIR)/stamp: mkdir -p $(DEPDIR) touch $(DEPDIR)/stamp include $(wildcard $(DEPDIR)/*.Pdep) .PHONY: clean distclean distclean: clean $(RM) Makefile $(RM) ../Makefile.template clean: $(RM) -r .deps .libs *.o *.lo ../*.o ../*.lo core libarch.a fakeroot-ng-0.18/config.sub0000755000175000017500000010344512131751664014052 0ustar sunsun#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2010-01-22' # 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., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted GNU 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. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # 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, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # 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 ;; * ) 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-newlib* | linux-uclibc* | \ uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-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 | -knuth | -cray | -microblaze) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -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 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -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/'` ;; -sco5v6*) # 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 | avr32 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nios | nios2 \ | ns16k | ns32k \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu | strongarm \ | tahoe | thumb | tic4x | tic80 | tron \ | ubicom32 \ | v850 | v850e \ | we32k \ | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | picochip) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; # 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-* | avr32-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile-* | tilegx-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # 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 ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; 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 ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; 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 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; 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 ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze) basic_machine=microblaze-xilinx ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; 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 ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; 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 ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; 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 ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; 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 ;; rdos) basic_machine=i386-pc os=-rdos ;; 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 ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; 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 ;; # This must be matched before tile*. tilegx*) basic_machine=tilegx-unknown os=-linux-gnu ;; tile*) basic_machine=tile-unknown os=-linux-gnu ;; 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 ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-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 ;; mmix) basic_machine=mmix-knuth ;; 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 ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) 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. -auroraux) os=-auroraux ;; -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* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -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* | -cegcc* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-newlib* | -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* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # 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* | -haiku* \ | -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 ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -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 score-*) os=-elf ;; spu-*) os=-elf ;; *-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 ;; mep-*) os=-elf ;; 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 ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-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 ;; -cnk*|-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 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: fakeroot-ng-0.18/configure0000755000175000017500000075036212131751663014003 0ustar sunsun#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.67 for fakeroot-ng 0.18. # # Report bugs to . # # # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. 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 IFS=$as_save_IFS ;; 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 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV export CONFIG_SHELL exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and shachar@debian.org $0: about your system, including any error possibly output $0: before this message. Then install a modern shell, or $0: manually run the script under such a shell if you do $0: have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; 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 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # 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 as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_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 sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # 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'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='fakeroot-ng' PACKAGE_TARNAME='fakeroot-ng' PACKAGE_VERSION='0.18' PACKAGE_STRING='fakeroot-ng 0.18' PACKAGE_BUGREPORT='shachar@debian.org' PACKAGE_URL='' ac_unique_file="parent.h" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_header_list= ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS RANLIB LN_S am__fastdepCXX_FALSE am__fastdepCXX_TRUE CXXDEPMODE ac_ct_CXX CXXFLAGS CXX EGREP GREP CPP am__fastdepCC_FALSE am__fastdepCC_TRUE CCDEPMODE AMDEPBACKSLASH AMDEP_FALSE AMDEP_TRUE am__quote am__include DEPDIR OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC am__untar am__tar AMTAR am__leading_dot SET_MAKE AWK mkdir_p MKDIR_P INSTALL_STRIP_PROGRAM STRIP install_sh MAKEINFO AUTOHEADER AUTOMAKE AUTOCONF ACLOCAL VERSION PACKAGE CYGPATH_W am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM target_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking enable_dependency_tracking with_memdir ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP CXX CXXFLAGS CCC' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # 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. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= 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 case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -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) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$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 ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$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 ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) 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 ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$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_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=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 ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_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'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" 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 $as_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 ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # 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 the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | 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 test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # 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 fakeroot-ng 0.18 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 \`..'] 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] --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] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/fakeroot-ng] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF Program names: --program-prefix=PREFIX prepend PREFIX to installed program names --program-suffix=SUFFIX append SUFFIX to installed program names --program-transform-name=PROGRAM run sed PROGRAM on installed program names System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of fakeroot-ng 0.18:";; esac cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --disable-dependency-tracking speeds up one-time build --enable-dependency-tracking do not reject slow dependency extractors Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-memdir=DIR Where to create shared memory files (default /tmp) 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 LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor CXX C++ compiler command CXXFLAGS C++ compiler flags Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested 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 else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF fakeroot-ng configure 0.18 generated by GNU Autoconf 2.67 Copyright (C) 2010 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 fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval "test \"\${$3+set}\"" = set; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## --------------------------------- ## ## Report this to shachar@debian.org ## ## --------------------------------- ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} } # ac_fn_c_check_header_compile # ac_fn_cxx_try_compile LINENO # ---------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_cxx_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_cxx_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} as_fn_set_status $ac_retval } # ac_fn_cxx_try_compile # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- # Tests whether TYPE exists after having included INCLUDES, setting cache # variable VAR accordingly. ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 else eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else eval "$3=yes" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} } # ac_fn_c_check_type # ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES # --------------------------------------------- # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR # accordingly. ac_fn_c_check_decl () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack as_decl_name=`echo $2|sed 's/ *(.*//'` as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 $as_echo_n "checking whether $as_decl_name is declared... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { #ifndef $as_decl_name #ifdef __cplusplus (void) $as_decl_use; #else (void) $as_decl_name; #endif #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} } # ac_fn_c_check_decl # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || $as_test_x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval "test \"\${$3+set}\"" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. Prefer to if __STDC__ is defined, since exists even on freestanding compilers. */ #ifdef __STDC__ # include #else # include #endif #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* 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_$2 || defined __stub___$2 choke me #endif int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;} } # ac_fn_c_check_func cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by fakeroot-ng $as_me 0.18, which was generated by GNU Autoconf 2.67. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { 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` /usr/bin/hostinfo = `(/usr/bin/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=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&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_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=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append 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 as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset 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: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > 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 cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5 ; } 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. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi as_fn_append ac_header_list " stdlib.h" as_fn_append ac_header_list " unistd.h" as_fn_append ac_header_list " sys/param.h" # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; 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,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_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 # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_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. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## 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_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 as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if test "${ac_cv_build+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5 ;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if test "${ac_cv_host+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5 ;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if test "${ac_cv_target+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5 ;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- am__api_version='1.11' # 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. # Reject install programs that cannot install multiple files. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 $as_echo_n "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if test "${ac_cv_path_install+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$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 rm -rf conftest.one conftest.two conftest.dir echo one > conftest.one echo two > conftest.two mkdir conftest.dir if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && test -s conftest.one && test -s conftest.two && test -s conftest.dir/conftest.one && test -s conftest.dir/conftest.two then ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" break 3 fi fi fi done done ;; esac done IFS=$as_save_IFS rm -rf conftest.one conftest.two conftest.dir 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. Don't cache a # value for INSTALL within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. INSTALL=$ac_install_sh fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 $as_echo "$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' { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 $as_echo_n "checking whether build environment is sane... " >&6; } # Just in case sleep 1 echo timestamp > conftest.file # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. am_lf=' ' case `pwd` in *[\\\"\#\$\&\'\`$am_lf]*) as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5 ;; esac case $srcdir in *[\\\"\#\$\&\'\`$am_lf\ \ ]*) as_fn_error $? "unsafe srcdir value: \`$srcdir'" "$LINENO" 5 ;; esac # Do `set' in a subshell so we don't clobber the current shell's # arguments. Must try -L first in case configure is actually a # symlink; some systems play weird games with the mod time of symlinks # (eg FreeBSD returns the mod time of the symlink's containing # directory). if ( set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` if test "$*" = "X"; then # -L didn't work. set X `ls -t "$srcdir/configure" conftest.file` fi rm -f conftest.file if test "$*" != "X $srcdir/configure conftest.file" \ && test "$*" != "X conftest.file $srcdir/configure"; then # If neither matched, then we have a broken ls. This can happen # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". as_fn_error $? "ls -t appears to fail. Make sure there is not a broken alias in your environment" "$LINENO" 5 fi test "$2" = conftest.file ) then # Ok. : else as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } test "$program_prefix" != NONE && program_transform_name="s&^&$program_prefix&;$program_transform_name" # Use a double $ so make ignores it. test "$program_suffix" != NONE && program_transform_name="s&\$&$program_suffix&;$program_transform_name" # Double any \ or $. # By default was `s,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` # expand $ac_aux_dir to an absolute path am_aux_dir=`cd $ac_aux_dir && pwd` if test x"${MISSING+set}" != xset; then case $am_aux_dir in *\ * | *\ *) MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; *) MISSING="\${SHELL} $am_aux_dir/missing" ;; esac fi # Use eval to expand $SHELL if eval "$MISSING --run true"; then am_missing_run="$MISSING --run " else am_missing_run= { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5 $as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;} fi if test x"${install_sh}" != xset; then case $am_aux_dir in *\ * | *\ *) install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; *) install_sh="\${SHELL} $am_aux_dir/install-sh" esac fi # Installed binaries are usually stripped using `strip' when the user # run `make install-strip'. However `strip' might not be the right # tool to use in cross-compilation environments, therefore Automake # will honor the `STRIP' environment variable to overrule this program. if test "$cross_compiling" != no; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_STRIP+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 $as_echo "$STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_STRIP="strip" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 $as_echo "$ac_ct_STRIP" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then STRIP=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP fi else STRIP="$ac_cv_prog_STRIP" fi fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 $as_echo_n "checking for a thread-safe mkdir -p... " >&6; } if test -z "$MKDIR_P"; then if test "${ac_cv_path_mkdir+set}" = set; then : $as_echo_n "(cached) " >&6 else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in mkdir gmkdir; do for ac_exec_ext in '' $ac_executable_extensions; do { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir (GNU coreutils) '* | \ 'mkdir (coreutils) '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext break 3;; esac done done done IFS=$as_save_IFS fi test -d ./--version && rmdir ./--version if test "${ac_cv_path_mkdir+set}" = set; then MKDIR_P="$ac_cv_path_mkdir -p" else # As a last resort, use the slow shell script. Don't cache a # value for MKDIR_P within a source directory, because that will # break other packages using the cache if that directory is # removed, or if the value is a relative name. MKDIR_P="$ac_install_sh -d" fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 $as_echo "$MKDIR_P" >&6; } mkdir_p="$MKDIR_P" case $mkdir_p in [\\/$]* | ?:[\\/]*) ;; */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;; esac for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_AWK+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_AWK="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 $as_echo "$AWK" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$AWK" && break done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\"" = set; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } SET_MAKE= else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi rm -rf .tst 2>/dev/null mkdir .tst 2>/dev/null if test -d .tst; then am__leading_dot=. else am__leading_dot=_ fi rmdir .tst 2>/dev/null if test "`cd $srcdir && pwd`" != "`pwd`"; then # Use -I$(srcdir) only when $(srcdir) != ., so that make's output # is not polluted with repeated "-I." am__isrc=' -I$(srcdir)' # test to see if srcdir already configured if test -f $srcdir/config.status; then as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 fi fi # test whether we have cygpath if test -z "$CYGPATH_W"; then if (cygpath --version) >/dev/null 2>/dev/null; then CYGPATH_W='cygpath -w' else CYGPATH_W=echo fi fi # Define the identity of the package. PACKAGE='fakeroot-ng' VERSION='0.18' cat >>confdefs.h <<_ACEOF #define PACKAGE "$PACKAGE" _ACEOF cat >>confdefs.h <<_ACEOF #define VERSION "$VERSION" _ACEOF # Some tools Automake needs. ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} # We need awk for the "check" target. The system "awk" is bad on # some platforms. # Always define AMTAR for backward compatibility. AMTAR=${AMTAR-"${am_missing_run}tar"} am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -' ac_config_headers="$ac_config_headers config.h" DEPDIR="${am__leading_dot}deps" ac_config_commands="$ac_config_commands depfiles" am_make=${MAKE-make} cat > confinc << 'END' am__doit: @echo this is the am__doit target .PHONY: am__doit END # If we don't find an include directive, just comment out the code. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 $as_echo_n "checking for style of include used by $am_make... " >&6; } am__include="#" am__quote= _am_result=none # First try GNU make style include. echo "include confinc" > confmf # Ignore all kinds of additional output from `make'. case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=include am__quote= _am_result=GNU ;; esac # Now try BSD make style include. if test "$am__include" = "#"; then echo '.include "confinc"' > confmf case `$am_make -s -f confmf 2> /dev/null` in #( *the\ am__doit\ target*) am__include=.include am__quote="\"" _am_result=BSD ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 $as_echo "$_am_result" >&6; } rm -f confinc confmf # Check whether --enable-dependency-tracking was given. if test "${enable_dependency_tracking+set}" = set; then : enableval=$enable_dependency_tracking; fi if test "x$enable_dependency_tracking" != xno; then am_depcomp="$ac_aux_dir/depcomp" AMDEPBACKSLASH='\' fi if test "x$enable_dependency_tracking" != xno; then AMDEP_TRUE= AMDEP_FALSE='#' else AMDEP_TRUE='#' AMDEP_FALSE= 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 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$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" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS 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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5 ; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM 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. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5 ; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; 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 | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5 ; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5 ; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if test "${ac_cv_objext+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5 ; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if test "${ac_cv_c_compiler_gnu+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if test "${ac_cv_prog_cc_g+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if test "${ac_cv_prog_cc_c89+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 -std 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 -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 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 for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : 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 depcc="$CC" am_compiler_list= { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 $as_echo_n "checking dependency style of $depcc... " >&6; } if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named `D' -- because `-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CC_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with # Solaris 8's {/usr,}/bin/sh. touch sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with `-c' and `-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle `-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # after this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvisualcpp | msvcmsys) # This compiler won't grok `-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CC_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then am__fastdepCC_TRUE= am__fastdepCC_FALSE='#' else am__fastdepCC_TRUE='#' am__fastdepCC_FALSE= 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&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 : $as_echo_n "(cached) " >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i 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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5 ; } 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if test "${ac_cv_path_GREP+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if test "${ac_cv_path_EGREP+set}" = set; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if test "${ac_cv_header_stdc+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #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)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h 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=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_header_mongrel "$LINENO" "minix/config.h" "ac_cv_header_minix_config_h" "$ac_includes_default" if test "x$ac_cv_header_minix_config_h" = x""yes; then : MINIX=yes else MINIX= fi if test "$MINIX" = yes; then $as_echo "#define _POSIX_SOURCE 1" >>confdefs.h $as_echo "#define _POSIX_1_SOURCE 2" >>confdefs.h $as_echo "#define _MINIX 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5 $as_echo_n "checking whether it is safe to define __EXTENSIONS__... " >&6; } if test "${ac_cv_safe_to_define___extensions__+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ # define __EXTENSIONS__ 1 $ac_includes_default int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_safe_to_define___extensions__=yes else ac_cv_safe_to_define___extensions__=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5 $as_echo "$ac_cv_safe_to_define___extensions__" >&6; } test $ac_cv_safe_to_define___extensions__ = yes && $as_echo "#define __EXTENSIONS__ 1" >>confdefs.h $as_echo "#define _ALL_SOURCE 1" >>confdefs.h $as_echo "#define _GNU_SOURCE 1" >>confdefs.h $as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h $as_echo "#define _TANDEM_SOURCE 1" >>confdefs.h # Checks for programs. ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if test -z "$CXX"; then if test -n "$CCC"; then CXX=$CCC else if test -n "$ac_tool_prefix"; then for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CXX+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$CXX"; then ac_cv_prog_CXX="$CXX" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 $as_echo "$CXX" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CXX" && break done fi if test -z "$CXX"; then ac_ct_CXX=$CXX for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CXX"; then ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CXX="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 $as_echo "$ac_ct_CXX" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CXX" && break done if test "x$ac_ct_CXX" = x; then CXX="g++" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CXX=$ac_ct_CXX fi fi fi fi # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } if test "${ac_cv_cxx_compiler_gnu+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_cxx_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 $as_echo "$ac_cv_cxx_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GXX=yes else GXX= fi ac_test_CXXFLAGS=${CXXFLAGS+set} ac_save_CXXFLAGS=$CXXFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 $as_echo_n "checking whether $CXX accepts -g... " >&6; } if test "${ac_cv_prog_cxx_g+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_save_cxx_werror_flag=$ac_cxx_werror_flag ac_cxx_werror_flag=yes ac_cv_prog_cxx_g=no CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_cv_prog_cxx_g=yes else CXXFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : else ac_cxx_werror_flag=$ac_save_cxx_werror_flag CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : ac_cv_prog_cxx_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cxx_werror_flag=$ac_save_cxx_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 $as_echo "$ac_cv_prog_cxx_g" >&6; } if test "$ac_test_CXXFLAGS" = set; then CXXFLAGS=$ac_save_CXXFLAGS elif test $ac_cv_prog_cxx_g = yes; then if test "$GXX" = yes; then CXXFLAGS="-g -O2" else CXXFLAGS="-g" fi else if test "$GXX" = yes; then CXXFLAGS="-O2" else CXXFLAGS= fi 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 depcc="$CXX" am_compiler_list= { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 $as_echo_n "checking dependency style of $depcc... " >&6; } if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named `D' -- because `-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CXX_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with # Solaris 8's {/usr,}/bin/sh. touch sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with `-c' and `-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle `-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # after this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvisualcpp | msvcmsys) # This compiler won't grok `-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CXX_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CXX_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 $as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then am__fastdepCXX_TRUE= am__fastdepCXX_FALSE='#' else am__fastdepCXX_TRUE='#' am__fastdepCXX_FALSE= 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 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$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" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS 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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_CC+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5 ; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if test "${ac_cv_c_compiler_gnu+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if test "${ac_cv_prog_cc_g+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if test "${ac_cv_prog_cc_c89+set}" = set; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 -std 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 -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 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 for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : 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 depcc="$CC" am_compiler_list= { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 $as_echo_n "checking dependency style of $depcc... " >&6; } if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up # making a dummy file named `D' -- because `-MD' means `put the output # in D'. mkdir conftest.dir # Copy depcomp to subdir because otherwise we won't find it if we're # using a relative directory. cp "$am_depcomp" conftest.dir cd conftest.dir # We will build objects and dependencies in a subdirectory because # it helps to detect inapplicable dependency modes. For instance # both Tru64's cc and ICC support -MD to output dependencies as a # side effect of compilation, but ICC will put the dependencies in # the current directory while Tru64 will put them in the object # directory. mkdir sub am_cv_CC_dependencies_compiler_type=none if test "$am_compiler_list" = ""; then am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` fi am__universal=false case " $depcc " in #( *\ -arch\ *\ -arch\ *) am__universal=true ;; esac for depmode in $am_compiler_list; do # Setup a source with many dependencies, because some compilers # like to wrap large dependency lists on column 80 (with \), and # we should not choose a depcomp mode which is confused by this. # # We need to recreate these files for each test, as the compiler may # overwrite some of them when testing with obscure command lines. # This happens at least with the AIX C compiler. : > sub/conftest.c for i in 1 2 3 4 5 6; do echo '#include "conftst'$i'.h"' >> sub/conftest.c # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with # Solaris 8's {/usr,}/bin/sh. touch sub/conftst$i.h done echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf # We check with `-c' and `-o' for the sake of the "dashmstdout" # mode. It turns out that the SunPro C++ compiler does not properly # handle `-M -o', and we need to detect this. Also, some Intel # versions had trouble with output in subdirs am__obj=sub/conftest.${OBJEXT-o} am__minus_obj="-o $am__obj" case $depmode in gcc) # This depmode causes a compiler race in universal mode. test "$am__universal" = false || continue ;; nosideeffect) # after this tag, mechanisms are not by side-effect, so they'll # only be used when explicitly requested if test "x$enable_dependency_tracking" = xyes; then continue else break fi ;; msvisualcpp | msvcmsys) # This compiler won't grok `-c -o', but also, the minuso test has # not run yet. These depmodes are late enough in the game, and # so weak that their functioning should not be impacted. am__obj=conftest.${OBJEXT-o} am__minus_obj= ;; none) break ;; esac if depmode=$depmode \ source=sub/conftest.c object=$am__obj \ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ >/dev/null 2>conftest.err && grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && grep $am__obj sub/conftest.Po > /dev/null 2>&1 && ${MAKE-make} -s -f confmf > /dev/null 2>&1; then # icc doesn't choke on unknown options, it will just issue warnings # or remarks (even with -Werror). So we grep stderr for any message # that says an option was ignored or not supported. # When given -MP, icc 7.0 and 7.1 complain thusly: # icc: Command line warning: ignoring option '-M'; no argument required # The diagnosis changed in icc 8.0: # icc: Command line remark: option '-MP' not supported if (grep 'ignoring option' conftest.err || grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else am_cv_CC_dependencies_compiler_type=$depmode break fi fi done cd .. rm -rf conftest.dir else am_cv_CC_dependencies_compiler_type=none fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then am__fastdepCC_TRUE= am__fastdepCC_FALSE='#' else am__fastdepCC_TRUE='#' am__fastdepCC_FALSE= 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&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 : $as_echo_n "(cached) " >&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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i 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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5 ; } 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 for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_AWK+set}" = set; then : $as_echo_n "(cached) " >&6 else if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # 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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_AWK="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 $as_echo "$AWK" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$AWK" && break done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 $as_echo_n "checking whether ln -s works... " >&6; } LN_S=$as_ln_s if test "$LN_S" = "ln -s"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 $as_echo "no, using $LN_S" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\"" = set; then : $as_echo_n "(cached) " >&6 else cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in *@@@%%%=?*=@@@%%%*) eval ac_cv_prog_make_${ac_make}_set=yes;; *) eval ac_cv_prog_make_${ac_make}_set=no;; esac rm -f conftest.make fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } SET_MAKE= else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi 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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_RANLIB+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 $as_echo "$RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "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 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then : $as_echo_n "(cached) " >&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 { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_RANLIB="ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 $as_echo "$ac_ct_RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_RANLIB" = x; then RANLIB=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB fi 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 # Checks for libraries. # Checks for header files. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if test "${ac_cv_header_stdc+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #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)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 $as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } if test "${ac_cv_header_sys_wait_h+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #ifndef WEXITSTATUS # define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8) #endif #ifndef WIFEXITED # define WIFEXITED(stat_val) (((stat_val) & 255) == 0) #endif int main () { int s; wait (&s); s = WIFEXITED (s) ? WEXITSTATUS (s) : 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_sys_wait_h=yes else ac_cv_header_sys_wait_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 $as_echo "$ac_cv_header_sys_wait_h" >&6; } if test $ac_cv_header_sys_wait_h = yes; then $as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h fi for ac_header in fcntl.h limits.h stdlib.h string.h sys/file.h sys/socket.h sys/time.h unistd.h sys/prctl.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done # Checks for typedefs, structures, and compiler characteristics. { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5 $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; } if test "${ac_cv_header_stdbool_h+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #ifndef bool "error: bool is not defined" #endif #ifndef false "error: false is not defined" #endif #if false "error: false is not 0" #endif #ifndef true "error: true is not defined" #endif #if true != 1 "error: true is not 1" #endif #ifndef __bool_true_false_are_defined "error: __bool_true_false_are_defined is not defined" #endif struct s { _Bool s: 1; _Bool t; } s; char a[true == 1 ? 1 : -1]; char b[false == 0 ? 1 : -1]; char c[__bool_true_false_are_defined == 1 ? 1 : -1]; char d[(bool) 0.5 == true ? 1 : -1]; bool e = &s; char f[(_Bool) 0.0 == false ? 1 : -1]; char g[true]; char h[sizeof (_Bool)]; char i[sizeof s.t]; enum { j = false, k = true, l = false * true, m = true * 256 }; /* The following fails for HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */ _Bool n[m]; char o[sizeof n == m * sizeof n[0] ? 1 : -1]; char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1]; # if defined __xlc__ || defined __GNUC__ /* Catch a bug in IBM AIX xlc compiler version 6.0.0.0 reported by James Lemley on 2005-10-05; see http://lists.gnu.org/archive/html/bug-coreutils/2005-10/msg00086.html This test is not quite right, since xlc is allowed to reject this program, as the initializer for xlcbug is not one of the forms that C requires support for. However, doing the test right would require a runtime test, and that would make cross-compilation harder. Let us hope that IBM fixes the xlc bug, and also adds support for this kind of constant expression. In the meantime, this test will reject xlc, which is OK, since our stdbool.h substitute should suffice. We also test this with GCC, where it should work, to detect more quickly whether someone messes up the test in the future. */ char digs[] = "0123456789"; int xlcbug = 1 / (&(digs + 5)[-2 + (bool) 1] == &digs[4] ? 1 : -1); # endif /* Catch a bug in an HP-UX C compiler. See http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html */ _Bool q = true; _Bool *pq = &q; int main () { *pq |= q; *pq |= ! q; /* Refer to every declared value, to avoid compiler optimizations. */ return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l + !m + !n + !o + !p + !q + !pq); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdbool_h=yes else ac_cv_header_stdbool_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5 $as_echo "$ac_cv_header_stdbool_h" >&6; } ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default" if test "x$ac_cv_type__Bool" = x""yes; then : cat >>confdefs.h <<_ACEOF #define HAVE__BOOL 1 _ACEOF fi if test $ac_cv_header_stdbool_h = yes; then $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 $as_echo_n "checking for an ANSI C-conforming const... " >&6; } if test "${ac_cv_c_const+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { /* FIXME: Include the comments suggested by Paul. */ #ifndef __cplusplus /* Ultrix mips cc rejects this. */ typedef int charset[2]; const charset cs; /* SunOS 4.1.1 cc rejects this. */ char const *const *pcpcc; char **ppc; /* NEC SVR4.0.2 mips cc rejects this. */ struct point {int x, y;}; static struct point const zero = {0,0}; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; pcpcc = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++pcpcc; ppc = (char**) pcpcc; pcpcc = (char const *const *) ppc; { /* SCO 3.2v4 cc rejects this. */ char *t; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; if (s) return 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25, 17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; }; struct s *b; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x; #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_const=yes else ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 $as_echo "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then $as_echo "#define const /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 $as_echo_n "checking for uid_t in sys/types.h... " >&6; } if test "${ac_cv_type_uid_t+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* 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 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 $as_echo "$ac_cv_type_uid_t" >&6; } if test $ac_cv_type_uid_t = no; then $as_echo "#define uid_t int" >>confdefs.h $as_echo "#define gid_t int" >>confdefs.h fi ac_fn_c_check_type "$LINENO" "mode_t" "ac_cv_type_mode_t" "$ac_includes_default" if test "x$ac_cv_type_mode_t" = x""yes; then : else cat >>confdefs.h <<_ACEOF #define mode_t int _ACEOF fi ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" if test "x$ac_cv_type_pid_t" = x""yes; then : else cat >>confdefs.h <<_ACEOF #define pid_t int _ACEOF fi ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" if test "x$ac_cv_type_size_t" = x""yes; then : else cat >>confdefs.h <<_ACEOF #define size_t unsigned int _ACEOF fi ac_fn_c_check_type "$LINENO" "ssize_t" "ac_cv_type_ssize_t" "$ac_includes_default" if test "x$ac_cv_type_ssize_t" = x""yes; then : else cat >>confdefs.h <<_ACEOF #define ssize_t int _ACEOF fi ac_fn_c_check_decl "$LINENO" "PR_SET_PTRACER" "ac_cv_have_decl_PR_SET_PTRACER" "#include " if test "x$ac_cv_have_decl_PR_SET_PTRACER" = x""yes; then : ac_have_decl=1 else ac_have_decl=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_DECL_PR_SET_PTRACER $ac_have_decl _ACEOF $as_echo "#define ROOT_UID 0" >>confdefs.h $as_echo "#define ROOT_GID 0" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PTRACE_GETREGS" >&5 $as_echo_n "checking for PTRACE_GETREGS... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { ptrace(PTRACE_GETREGS, 0, 0, 0); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } $as_echo "#define HAVE_PTRACE_GETREGS 1" >>confdefs.h else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PTRACE_PEEKUSER" >&5 $as_echo_n "checking for PTRACE_PEEKUSER... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { ptrace(PTRACE_PEEKUSER, 0, 0, 0); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } $as_echo "#define HAVE_PTRACE_PEEKUSER 1" >>confdefs.h else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu #AC_LANG_WERROR { $as_echo "$as_me:${as_lineno-$LINENO}: checking what flags are needed for compiler support of the ISO C++11 standard" >&5 $as_echo_n "checking what flags are needed for compiler support of the ISO C++11 standard... " >&6; } saved_CXXFLAGS=$CXXFLAGS CXXFLAGS="$saved_CXXFLAGS -Werror" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include class testcpp11 { public: testcpp11() = default; }; int main () { std::unordered_map test; decltype(test)::iterator iterator; int *nullable=nullptr; int i; if( nullable!=0 ) nullable=&i; ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 $as_echo "none" >&6; } CXXFLAGS="$saved_CXXFLAGS" else CXXFLAGS="$saved_CXXFLAGS -std=c++11 -Werror" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include class testcpp11 { public: testcpp11() = default; }; int main () { std::unordered_map test; decltype(test)::iterator iterator; int *nullable=nullptr; int i; if( nullable!=0 ) nullable=&i; ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: -std=c++11" >&5 $as_echo "-std=c++11" >&6; } CXXFLAGS="$saved_CXXFLAGS -std=c++11" else { $as_echo "$as_me:${as_lineno-$LINENO}: result: not supported" >&5 $as_echo "not supported" >&6; } as_fn_error $? "Fakeroot-ng needs a compiler that supports C++11. If you are using gcc, that means version 4.7 or higher." "$LINENO" 5 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports custom printf style protection" >&5 $as_echo_n "checking whether compiler supports custom printf style protection... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int dummy( const char *format, ... ) __attribute__ ((format(printf, 1, 2))); int main () { ; return 0; } _ACEOF if ac_fn_cxx_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: __attribute__ ((format(...)))" >&5 $as_echo "__attribute__ ((format(...)))" >&6; } $as_echo "#define COMPHINT_PRINTF( f, c ) __attribute__ (( format ( printf, f, c )))" >>confdefs.h else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } as_fn_error $? "Compiler does not support format string checking on custom functions" "$LINENO" 5 fi rm -f core 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 # Checks for library functions. for ac_header in unistd.h do : ac_fn_c_check_header_mongrel "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$ac_includes_default" if test "x$ac_cv_header_unistd_h" = x""yes; then : cat >>confdefs.h <<_ACEOF #define HAVE_UNISTD_H 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working chown" >&5 $as_echo_n "checking for working chown... " >&6; } if test "${ac_cv_func_chown_works+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_chown_works=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default #include int main () { char *f = "conftest.chown"; struct stat before, after; if (creat (f, 0600) < 0) return 1; if (stat (f, &before) < 0) return 1; if (chown (f, (uid_t) -1, (gid_t) -1) == -1) return 1; if (stat (f, &after) < 0) return 1; return ! (before.st_uid == after.st_uid && before.st_gid == after.st_gid); ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_chown_works=yes else ac_cv_func_chown_works=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi rm -f conftest.chown fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_chown_works" >&5 $as_echo "$ac_cv_func_chown_works" >&6; } if test $ac_cv_func_chown_works = yes; then $as_echo "#define HAVE_CHOWN 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for error_at_line" >&5 $as_echo_n "checking for error_at_line... " >&6; } if test "${ac_cv_lib_error_at_line+set}" = set; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { error_at_line (0, 0, "", 0, "an error occurred"); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_error_at_line=yes else ac_cv_lib_error_at_line=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_error_at_line" >&5 $as_echo "$ac_cv_lib_error_at_line" >&6; } if test $ac_cv_lib_error_at_line = no; then case " $LIBOBJS " in *" error.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS error.$ac_objext" ;; esac fi for ac_header in vfork.h do : ac_fn_c_check_header_mongrel "$LINENO" "vfork.h" "ac_cv_header_vfork_h" "$ac_includes_default" if test "x$ac_cv_header_vfork_h" = x""yes; then : cat >>confdefs.h <<_ACEOF #define HAVE_VFORK_H 1 _ACEOF fi done for ac_func in fork vfork do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done if test "x$ac_cv_func_fork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working fork" >&5 $as_echo_n "checking for working fork... " >&6; } if test "${ac_cv_func_fork_works+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_fork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* By Ruediger Kuhlmann. */ return fork () < 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_fork_works=yes else ac_cv_func_fork_works=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works" >&5 $as_echo "$ac_cv_func_fork_works" >&6; } else ac_cv_func_fork_works=$ac_cv_func_fork fi if test "x$ac_cv_func_fork_works" = xcross; then case $host in *-*-amigaos* | *-*-msdosdjgpp*) # Override, as these systems have only a dummy fork() stub ac_cv_func_fork_works=no ;; *) ac_cv_func_fork_works=yes ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&2;} fi ac_cv_func_vfork_works=$ac_cv_func_vfork if test "x$ac_cv_func_vfork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working vfork" >&5 $as_echo_n "checking for working vfork... " >&6; } if test "${ac_cv_func_vfork_works+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_vfork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Thanks to Paul Eggert for this test. */ $ac_includes_default #include #ifdef HAVE_VFORK_H # include #endif /* On some sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include , but some compilers (e.g. gcc -O) don't grok . Test for this by using a static variable whose address is put into a register that is clobbered by the vfork. */ static void #ifdef __cplusplus sparc_address_test (int arg) # else sparc_address_test (arg) int arg; #endif { static pid_t child; if (!child) { child = vfork (); if (child < 0) { perror ("vfork"); _exit(2); } if (!child) { arg = getpid(); write(-1, "", 0); _exit (arg); } } } int main () { pid_t parent = getpid (); pid_t child; sparc_address_test (0); child = vfork (); if (child == 0) { /* Here is another test for sparc vfork register problems. This test uses lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can't possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. */ pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); /* Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. */ if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1); /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent from child file descriptors. If the child closes a descriptor before it execs or exits, this munges the parent's descriptor as well. Test for this by closing stdout in the child. */ _exit(close(fileno(stdout)) != 0); } else { int status; struct stat st; while (wait(&status) != child) ; return ( /* Was there some problem with vforking? */ child < 0 /* Did the child fail? (This shouldn't happen.) */ || status /* Did the vfork/compiler bug occur? */ || parent != getpid() /* Did the file descriptor bug occur? */ || fstat(fileno(stdout), &st) != 0 ); } } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_vfork_works=yes else ac_cv_func_vfork_works=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works" >&5 $as_echo "$ac_cv_func_vfork_works" >&6; } fi; if test "x$ac_cv_func_fork_works" = xcross; then ac_cv_func_vfork_works=$ac_cv_func_vfork { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&2;} fi if test "x$ac_cv_func_vfork_works" = xyes; then $as_echo "#define HAVE_WORKING_VFORK 1" >>confdefs.h else $as_echo "#define vfork fork" >>confdefs.h fi if test "x$ac_cv_func_fork_works" = xyes; then $as_echo "#define HAVE_WORKING_FORK 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether lstat correctly handles trailing slash" >&5 $as_echo_n "checking whether lstat correctly handles trailing slash... " >&6; } if test "${ac_cv_func_lstat_dereferences_slashed_symlink+set}" = set; then : $as_echo_n "(cached) " >&6 else rm -f conftest.sym conftest.file echo >conftest.file if test "$as_ln_s" = "ln -s" && ln -s conftest.file conftest.sym; then if test "$cross_compiling" = yes; then : ac_cv_func_lstat_dereferences_slashed_symlink=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { struct stat sbuf; /* Linux will dereference the symlink and fail, as required by POSIX. That is better in the sense that it means we will not have to compile and use the lstat wrapper. */ return lstat ("conftest.sym/", &sbuf) == 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_lstat_dereferences_slashed_symlink=yes else ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi else # If the `ln -s' command failed, then we probably don't even # have an lstat function. ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f conftest.sym conftest.file fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_lstat_dereferences_slashed_symlink" >&5 $as_echo "$ac_cv_func_lstat_dereferences_slashed_symlink" >&6; } test $ac_cv_func_lstat_dereferences_slashed_symlink = yes && cat >>confdefs.h <<_ACEOF #define LSTAT_FOLLOWS_SLASHED_SYMLINK 1 _ACEOF if test "x$ac_cv_func_lstat_dereferences_slashed_symlink" = xno; then case " $LIBOBJS " in *" lstat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS lstat.$ac_objext" ;; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether lstat accepts an empty string" >&5 $as_echo_n "checking whether lstat accepts an empty string... " >&6; } if test "${ac_cv_func_lstat_empty_string_bug+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_lstat_empty_string_bug=yes else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { struct stat sbuf; return lstat ("", &sbuf) == 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_lstat_empty_string_bug=no else ac_cv_func_lstat_empty_string_bug=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_lstat_empty_string_bug" >&5 $as_echo "$ac_cv_func_lstat_empty_string_bug" >&6; } if test $ac_cv_func_lstat_empty_string_bug = yes; then case " $LIBOBJS " in *" lstat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS lstat.$ac_objext" ;; esac cat >>confdefs.h <<_ACEOF #define HAVE_LSTAT_EMPTY_STRING_BUG 1 _ACEOF fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether lstat correctly handles trailing slash" >&5 $as_echo_n "checking whether lstat correctly handles trailing slash... " >&6; } if test "${ac_cv_func_lstat_dereferences_slashed_symlink+set}" = set; then : $as_echo_n "(cached) " >&6 else rm -f conftest.sym conftest.file echo >conftest.file if test "$as_ln_s" = "ln -s" && ln -s conftest.file conftest.sym; then if test "$cross_compiling" = yes; then : ac_cv_func_lstat_dereferences_slashed_symlink=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { struct stat sbuf; /* Linux will dereference the symlink and fail, as required by POSIX. That is better in the sense that it means we will not have to compile and use the lstat wrapper. */ return lstat ("conftest.sym/", &sbuf) == 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_lstat_dereferences_slashed_symlink=yes else ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi else # If the `ln -s' command failed, then we probably don't even # have an lstat function. ac_cv_func_lstat_dereferences_slashed_symlink=no fi rm -f conftest.sym conftest.file fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_lstat_dereferences_slashed_symlink" >&5 $as_echo "$ac_cv_func_lstat_dereferences_slashed_symlink" >&6; } test $ac_cv_func_lstat_dereferences_slashed_symlink = yes && cat >>confdefs.h <<_ACEOF #define LSTAT_FOLLOWS_SLASHED_SYMLINK 1 _ACEOF if test "x$ac_cv_func_lstat_dereferences_slashed_symlink" = xno; then case " $LIBOBJS " in *" lstat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS lstat.$ac_objext" ;; esac fi for ac_func in vprintf do : ac_fn_c_check_func "$LINENO" "vprintf" "ac_cv_func_vprintf" if test "x$ac_cv_func_vprintf" = x""yes; then : cat >>confdefs.h <<_ACEOF #define HAVE_VPRINTF 1 _ACEOF ac_fn_c_check_func "$LINENO" "_doprnt" "ac_cv_func__doprnt" if test "x$ac_cv_func__doprnt" = x""yes; then : $as_echo "#define HAVE_DOPRNT 1" >>confdefs.h fi fi done for ac_header in $ac_header_list do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in getpagesize do : ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" if test "x$ac_cv_func_getpagesize" = x""yes; then : cat >>confdefs.h <<_ACEOF #define HAVE_GETPAGESIZE 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 $as_echo_n "checking for working mmap... " >&6; } if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_mmap_fixed_mapped=no else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default /* malloc might have been renamed as rpl_malloc. */ #undef malloc /* Thanks to Mike Haertel and Jim Avera for this test. Here is a matrix of mmap possibilities: mmap private not fixed mmap private fixed at somewhere currently unmapped mmap private fixed at somewhere already mapped mmap shared not fixed mmap shared fixed at somewhere currently unmapped mmap shared fixed at somewhere already mapped For private mappings, we should verify that changes cannot be read() back from the file, nor mmap's back from the file at a different address. (There have been systems where private was not correctly implemented like the infamous i386 svr4.0, and systems where the VM page cache was not coherent with the file system buffer cache like early versions of FreeBSD and possibly contemporary NetBSD.) For shared mappings, we should conversely verify that changes get propagated back to all the places they're supposed to be. Grep wants private fixed already mapped. The main things grep needs to know about mmap are: * does it exist and is it safe to write into the mmap'd area * how to use it (BSD variants) */ #include #include #if !defined STDC_HEADERS && !defined HAVE_STDLIB_H char *malloc (); #endif /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef _SC_PAGESIZE # define getpagesize() sysconf(_SC_PAGESIZE) # else /* no _SC_PAGESIZE */ # ifdef HAVE_SYS_PARAM_H # include # ifdef EXEC_PAGESIZE # define getpagesize() EXEC_PAGESIZE # else /* no EXEC_PAGESIZE */ # ifdef NBPG # define getpagesize() NBPG * CLSIZE # ifndef CLSIZE # define CLSIZE 1 # endif /* no CLSIZE */ # else /* no NBPG */ # ifdef NBPC # define getpagesize() NBPC # else /* no NBPC */ # ifdef PAGESIZE # define getpagesize() PAGESIZE # endif /* PAGESIZE */ # endif /* no NBPC */ # endif /* no NBPG */ # endif /* no EXEC_PAGESIZE */ # else /* no HAVE_SYS_PARAM_H */ # define getpagesize() 8192 /* punt totally */ # endif /* no HAVE_SYS_PARAM_H */ # endif /* no _SC_PAGESIZE */ #endif /* no HAVE_GETPAGESIZE */ int main () { char *data, *data2, *data3; const char *cdata2; int i, pagesize; int fd, fd2; pagesize = getpagesize (); /* First, make a file with some known garbage in it. */ data = (char *) malloc (pagesize); if (!data) return 1; for (i = 0; i < pagesize; ++i) *(data + i) = rand (); umask (0); fd = creat ("conftest.mmap", 0600); if (fd < 0) return 2; if (write (fd, data, pagesize) != pagesize) return 3; close (fd); /* Next, check that the tail of a page is zero-filled. File must have non-zero length, otherwise we risk SIGBUS for entire page. */ fd2 = open ("conftest.txt", O_RDWR | O_CREAT | O_TRUNC, 0600); if (fd2 < 0) return 4; cdata2 = ""; if (write (fd2, cdata2, 1) != 1) return 5; data2 = (char *) mmap (0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0L); if (data2 == MAP_FAILED) return 6; for (i = 0; i < pagesize; ++i) if (*(data2 + i)) return 7; close (fd2); if (munmap (data2, pagesize)) return 8; /* Next, try to mmap the file at a fixed address which already has something else allocated at it. If we can, also make sure that we see the same garbage. */ fd = open ("conftest.mmap", O_RDWR); if (fd < 0) return 9; if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0L)) return 10; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data2 + i)) return 11; /* Finally, make sure that changes to the mapped area do not percolate back to the file as seen by read(). (This is a bug on some variants of i386 svr4.0.) */ for (i = 0; i < pagesize; ++i) *(data2 + i) = *(data2 + i) + 1; data3 = (char *) malloc (pagesize); if (!data3) return 12; if (read (fd, data3, pagesize) != pagesize) return 13; for (i = 0; i < pagesize; ++i) if (*(data + i) != *(data3 + i)) return 14; close (fd); return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_mmap_fixed_mapped=yes else ac_cv_func_mmap_fixed_mapped=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 $as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then $as_echo "#define HAVE_MMAP 1" >>confdefs.h fi rm -f conftest.mmap conftest.txt for ac_func in ftruncate getcwd memset mkdir munmap realpath select socket strchr strerror strtoul do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether openat class functions are supported" >&5 $as_echo_n "checking whether openat class functions are supported... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { struct stat stat; fstatat(AT_FDCWD, "/etc/passwd", &stat, AT_SYMLINK_NOFOLLOW); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } $as_echo "#define HAVE_OPENAT 1" >>confdefs.h else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #define _ATFILE_SOURCE #include #include int main () { struct stat stat; fstatat(AT_FDCWD, "/etc/passwd", &stat, AT_SYMLINK_NOFOLLOW); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: _ATFILE_SOURCE" >&5 $as_echo "_ATFILE_SOURCE" >&6; } $as_echo "#define HAVE_OPENAT 1" >>confdefs.h $as_echo "#define _ATFILE_SOURCE /**/" >>confdefs.h else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: checking what alternate location to use for shared memory files" >&5 $as_echo_n "checking what alternate location to use for shared memory files... " >&6; } # Check whether --with-memdir was given. if test "${with_memdir+set}" = set; then : withval=$with_memdir; if [ "$with_memdir" ] then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_memdir" >&5 $as_echo "$with_memdir" >&6; } cat >>confdefs.h <<_ACEOF #define DEFAULT_TMPDIR "$with_memdir" _ACEOF fi else { $as_echo "$as_me:${as_lineno-$LINENO}: result: /tmp" >&5 $as_echo "/tmp" >&6; } $as_echo "#define DEFAULT_TMPDIR \"/tmp\"" >>confdefs.h fi # Custom steps if [ "$target_os" = "linux-gnu" ] then target_os=linux fi case "$target_cpu" in i686|i586|i486) target_cpu=i386 ;; esac # Check whether we are ported to this platform { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether platform $target_os/$target_cpu is supported" >&5 $as_echo_n "checking whether platform $target_os/$target_cpu is supported... " >&6; } if [ ! -f "$srcdir/arch/$target_os/$target_cpu/platform_specific.h" ] then { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } echo "$srcdir" as_fn_error $? "Platform detected is not yet supported." "$LINENO" 5 else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi ac_config_files="$ac_config_files Makefile tests/Makefile arch/Makefile arch/$target_os/Makefile.template arch/$target_os/$target_cpu/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, we kill variables containing newlines. # 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. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}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 "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end 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" && { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} cat confcache >$cache_file else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} 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}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs if test -n "$EXEEXT"; then am__EXEEXT_TRUE= am__EXEEXT_FALSE='#' else am__EXEEXT_TRUE='#' am__EXEEXT_FALSE= fi if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then as_fn_error $? "conditional \"AMDEP\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi : ${CONFIG_STATUS=./config.status} ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $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} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. 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 IFS=$as_save_IFS ;; 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 $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; 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 if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # 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 ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # 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'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by fakeroot-ng $as_me 0.18, which was generated by GNU Autoconf 2.67. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" config_commands="$ac_config_commands" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent 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 Configuration commands: $config_commands Report bugs to ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ fakeroot-ng config.status 0.18 configured by $0, generated by GNU Autoconf 2.67, with options \\"\$ac_cs_config\\" Copyright (C) 2010 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' INSTALL='$INSTALL' MKDIR_P='$MKDIR_P' AWK='$AWK' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. 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=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; 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 || ac_write_fail=1 if \$ac_cs_recheck; then set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;; "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "tests/Makefile") CONFIG_FILES="$CONFIG_FILES tests/Makefile" ;; "arch/Makefile") CONFIG_FILES="$CONFIG_FILES arch/Makefile" ;; "arch/$target_os/Makefile.template") CONFIG_FILES="$CONFIG_FILES arch/$target_os/Makefile.template" ;; "arch/$target_os/$target_cpu/Makefile") CONFIG_FILES="$CONFIG_FILES arch/$target_os/$target_cpu/Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;; 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 test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= trap 'exit_status=$? { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries 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[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_t=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_t"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #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. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # 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. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # case $INSTALL in [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; esac ac_MKDIR_P=$MKDIR_P case $MKDIR_P in [\\/$]* | ?:[\\/]* ) ;; */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; esac _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;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&@abs_top_builddir@&$ac_abs_top_builddir&;t t s&@INSTALL@&$ac_INSTALL&;t t s&@MKDIR_P@&$ac_MKDIR_P&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$tmp/stdin" case $ac_file in -) cat "$tmp/out" && rm -f "$tmp/out";; *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" } >"$tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi # Compute "$ac_file"'s index in $config_headers. _am_arg="$ac_file" _am_stamp_count=1 for _am_header in $config_headers :; do case $_am_header in $_am_arg | $_am_arg:* ) break ;; * ) _am_stamp_count=`expr $_am_stamp_count + 1` ;; esac done echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || $as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$_am_arg" : 'X\(//\)[^/]' \| \ X"$_am_arg" : 'X\(//\)$' \| \ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$_am_arg" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'`/stamp-h$_am_stamp_count ;; :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 $as_echo "$as_me: executing $ac_file commands" >&6;} ;; esac case $ac_file$ac_mode in "depfiles":C) test x"$AMDEP_TRUE" != x"" || { # Autoconf 2.62 quotes --file arguments for eval, but not when files # are listed without --file. Let's play safe and only enable the eval # if we detect the quoting. case $CONFIG_FILES in *\'*) eval set x "$CONFIG_FILES" ;; *) set x $CONFIG_FILES ;; esac shift for mf do # Strip MF so we end up with the name of the file. mf=`echo "$mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile or not. # We used to match only the files named `Makefile.in', but # some people rename them; so instead we look at the file content. # Grep'ing the first line is not enough: some people post-process # each Makefile.in and add a new line on top of each file to say so. # Grep'ing the whole file is not good either: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then dirpart=`$as_dirname -- "$mf" || $as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$mf" : 'X\(//\)[^/]' \| \ X"$mf" : 'X\(//\)$' \| \ X"$mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` else continue fi # Extract the definition of DEPDIR, am__include, and am__quote # from the Makefile without running `make'. DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` test -z "$DEPDIR" && continue am__include=`sed -n 's/^am__include = //p' < "$mf"` test -z "am__include" && continue am__quote=`sed -n 's/^am__quote = //p' < "$mf"` # When using ansi2knr, U may be empty or an underscore; expand it U=`sed -n 's/^U = //p' < "$mf"` # Find all dependency output files, they are included files with # $(DEPDIR) in their names. We invoke sed twice because it is the # simplest approach to changing $(DEPDIR) to its actual value in the # expansion. for file in `sed -n " s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do # Make sure the directory exists. test -f "$dirpart/$file" && continue fdir=`$as_dirname -- "$file" || $as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$file" : 'X\(//\)[^/]' \| \ X"$file" : 'X\(//\)$' \| \ X"$file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir=$dirpart/$fdir; as_fn_mkdir_p # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done done } ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # 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 || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi fakeroot-ng-0.18/depcomp0000755000175000017500000004426712131751664013452 0ustar sunsun#! /bin/sh # depcomp - compile a program generating dependencies as side-effects scriptversion=2009-04-28.21; # UTC # Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009 Free # Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # 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 Alexandre Oliva . case $1 in '') echo "$0: No command. Try \`$0 --help' for more information." 1>&2 exit 1; ;; -h | --h*) cat <<\EOF Usage: depcomp [--help] [--version] PROGRAM [ARGS] Run PROGRAMS ARGS to compile a file, generating dependencies as side-effects. Environment variables: depmode Dependency tracking mode. source Source file read by `PROGRAMS ARGS'. object Object file output by `PROGRAMS ARGS'. DEPDIR directory where to store dependencies. depfile Dependency file to output. tmpdepfile Temporary file to use when outputing dependencies. libtool Whether libtool is used (yes/no). Report bugs to . EOF exit $? ;; -v | --v*) echo "depcomp $scriptversion" exit $? ;; esac if test -z "$depmode" || test -z "$source" || test -z "$object"; then echo "depcomp: Variables source, object and depmode must be set" 1>&2 exit 1 fi # Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. depfile=${depfile-`echo "$object" | sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} rm -f "$tmpdepfile" # Some modes work just like other modes, but use different flags. We # parameterize here, but still list the modes in the big case below, # to make depend.m4 easier to write. Note that we *cannot* use a case # here, because this file can only contain one case statement. if test "$depmode" = hp; then # HP compiler uses -M and no extra arg. gccflag=-M depmode=gcc fi if test "$depmode" = dashXmstdout; then # This is just like dashmstdout with a different argument. dashmflag=-xM depmode=dashmstdout fi cygpath_u="cygpath -u -f -" if test "$depmode" = msvcmsys; then # This is just like msvisualcpp but w/o cygpath translation. # Just convert the backslash-escaped backslashes to single forward # slashes to satisfy depend.m4 cygpath_u="sed s,\\\\\\\\,/,g" depmode=msvisualcpp fi case "$depmode" in gcc3) ## gcc 3 implements dependency tracking that does exactly what ## we want. Yay! Note: for some reason libtool 1.4 doesn't like ## it if -MD -MP comes after the -MF stuff. Hmm. ## Unfortunately, FreeBSD c89 acceptance of flags depends upon ## the command line argument order; so add the flags where they ## appear in depend2.am. Note that the slowdown incurred here ## affects only configure: in makefiles, %FASTDEP% shortcuts this. for arg do case $arg in -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; *) set fnord "$@" "$arg" ;; esac shift # fnord shift # $arg done "$@" stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile" exit $stat fi mv "$tmpdepfile" "$depfile" ;; gcc) ## There are various ways to get dependency output from gcc. Here's ## why we pick this rather obscure method: ## - Don't want to use -MD because we'd like the dependencies to end ## up in a subdir. Having to rename by hand is ugly. ## (We might end up doing this anyway to support other compilers.) ## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like ## -MM, not -M (despite what the docs say). ## - Using -M directly means running the compiler twice (even worse ## than renaming). if test -z "$gccflag"; then gccflag=-MD, fi "$@" -Wp,"$gccflag$tmpdepfile" stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" echo "$object : \\" > "$depfile" alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ## The second -e expression handles DOS-style file names with drive letters. sed -e 's/^[^:]*: / /' \ -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" ## This next piece of magic avoids the `deleted header file' problem. ## The problem is that when a header file which appears in a .P file ## is deleted, the dependency causes make to die (because there is ## typically no way to rebuild the header). We avoid this by adding ## dummy dependencies for each header file. Too bad gcc doesn't do ## this for us directly. tr ' ' ' ' < "$tmpdepfile" | ## Some versions of gcc put a space before the `:'. On the theory ## that the space means something, we add a space to the output as ## well. ## Some versions of the HPUX 10.20 sed can't process this invocation ## correctly. Breaking it into two sed invocations is a workaround. sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; hp) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; sgi) if test "$libtool" = yes; then "$@" "-Wp,-MDupdate,$tmpdepfile" else "$@" -MDupdate "$tmpdepfile" fi stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files echo "$object : \\" > "$depfile" # Clip off the initial element (the dependent). Don't try to be # clever and replace this with sed code, as IRIX sed won't handle # lines with more than a fixed number of characters (4096 in # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; # the IRIX cc adds comments like `#:fec' to the end of the # dependency line. tr ' ' ' ' < "$tmpdepfile" \ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \ tr ' ' ' ' >> "$depfile" echo >> "$depfile" # The second pass generates a dummy entry for each header file. tr ' ' ' ' < "$tmpdepfile" \ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ >> "$depfile" else # The sourcefile does not contain any dependencies, so just # store a dummy comment line, to avoid errors with the Makefile # "include basename.Plo" scheme. echo "#dummy" > "$depfile" fi rm -f "$tmpdepfile" ;; aix) # The C for AIX Compiler uses -M and outputs the dependencies # in a .u file. In older versions, this file always lives in the # current directory. Also, the AIX compiler puts `$object:' at the # start of each line; $object doesn't have directory information. # Version 6 uses the directory in both cases. dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` test "x$dir" = "x$object" && dir= base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` if test "$libtool" = yes; then tmpdepfile1=$dir$base.u tmpdepfile2=$base.u tmpdepfile3=$dir.libs/$base.u "$@" -Wc,-M else tmpdepfile1=$dir$base.u tmpdepfile2=$dir$base.u tmpdepfile3=$dir$base.u "$@" -M fi stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" do test -f "$tmpdepfile" && break done if test -f "$tmpdepfile"; then # Each line is of the form `foo.o: dependent.h'. # Do two passes, one to just change these to # `$object: dependent.h' and one to simply `dependent.h:'. sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" # That's a tab and a space in the []. sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" else # The sourcefile does not contain any dependencies, so just # store a dummy comment line, to avoid errors with the Makefile # "include basename.Plo" scheme. echo "#dummy" > "$depfile" fi rm -f "$tmpdepfile" ;; icc) # Intel's C compiler understands `-MD -MF file'. However on # icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c # ICC 7.0 will fill foo.d with something like # foo.o: sub/foo.c # foo.o: sub/foo.h # which is wrong. We want: # sub/foo.o: sub/foo.c # sub/foo.o: sub/foo.h # sub/foo.c: # sub/foo.h: # ICC 7.1 will output # foo.o: sub/foo.c sub/foo.h # and will wrap long lines using \ : # foo.o: sub/foo.c ... \ # sub/foo.h ... \ # ... "$@" -MD -MF "$tmpdepfile" stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile" exit $stat fi rm -f "$depfile" # Each line is of the form `foo.o: dependent.h', # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. # Do two passes, one to just change these to # `$object: dependent.h' and one to simply `dependent.h:'. sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" # Some versions of the HPUX 10.20 sed can't process this invocation # correctly. Breaking it into two sed invocations is a workaround. sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; hp2) # The "hp" stanza above does not work with aCC (C++) and HP's ia64 # compilers, which have integrated preprocessors. The correct option # to use with these is +Maked; it writes dependencies to a file named # 'foo.d', which lands next to the object file, wherever that # happens to be. # Much of this is similar to the tru64 case; see comments there. dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` test "x$dir" = "x$object" && dir= base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` if test "$libtool" = yes; then tmpdepfile1=$dir$base.d tmpdepfile2=$dir.libs/$base.d "$@" -Wc,+Maked else tmpdepfile1=$dir$base.d tmpdepfile2=$dir$base.d "$@" +Maked fi stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile1" "$tmpdepfile2" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" do test -f "$tmpdepfile" && break done if test -f "$tmpdepfile"; then sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile" # Add `dependent.h:' lines. sed -ne '2,${ s/^ *// s/ \\*$// s/$/:/ p }' "$tmpdepfile" >> "$depfile" else echo "#dummy" > "$depfile" fi rm -f "$tmpdepfile" "$tmpdepfile2" ;; tru64) # The Tru64 compiler uses -MD to generate dependencies as a side # effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'. # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put # dependencies in `foo.d' instead, so we check for that too. # Subdirectories are respected. dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` test "x$dir" = "x$object" && dir= base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` if test "$libtool" = yes; then # With Tru64 cc, shared objects can also be used to make a # static library. This mechanism is used in libtool 1.4 series to # handle both shared and static libraries in a single compilation. # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d. # # With libtool 1.5 this exception was removed, and libtool now # generates 2 separate objects for the 2 libraries. These two # compilations output dependencies in $dir.libs/$base.o.d and # in $dir$base.o.d. We have to check for both files, because # one of the two compilations can be disabled. We should prefer # $dir$base.o.d over $dir.libs/$base.o.d because the latter is # automatically cleaned when .libs/ is deleted, while ignoring # the former would cause a distcleancheck panic. tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4 tmpdepfile2=$dir$base.o.d # libtool 1.5 tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5 tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504 "$@" -Wc,-MD else tmpdepfile1=$dir$base.o.d tmpdepfile2=$dir$base.d tmpdepfile3=$dir$base.d tmpdepfile4=$dir$base.d "$@" -MD fi stat=$? if test $stat -eq 0; then : else rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" exit $stat fi for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" do test -f "$tmpdepfile" && break done if test -f "$tmpdepfile"; then sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" # That's a tab and a space in the []. sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" else echo "#dummy" > "$depfile" fi rm -f "$tmpdepfile" ;; #nosideeffect) # This comment above is used by automake to tell side-effect # dependency tracking mechanisms from slower ones. dashmstdout) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout, regardless of -o. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # Remove `-o $object'. IFS=" " for arg do case $arg in -o) shift ;; $object) shift ;; *) set fnord "$@" "$arg" shift # fnord shift # $arg ;; esac done test -z "$dashmflag" && dashmflag=-M # Require at least two characters before searching for `:' # in the target name. This is to cope with DOS-style filenames: # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise. "$@" $dashmflag | sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile" rm -f "$depfile" cat < "$tmpdepfile" > "$depfile" tr ' ' ' ' < "$tmpdepfile" | \ ## Some versions of the HPUX 10.20 sed can't process this invocation ## correctly. Breaking it into two sed invocations is a workaround. sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; dashXmstdout) # This case only exists to satisfy depend.m4. It is never actually # run, as this mode is specially recognized in the preamble. exit 1 ;; makedepend) "$@" || exit $? # Remove any Libtool call if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # X makedepend shift cleared=no eat=no for arg do case $cleared in no) set ""; shift cleared=yes ;; esac if test $eat = yes; then eat=no continue fi case "$arg" in -D*|-I*) set fnord "$@" "$arg"; shift ;; # Strip any option that makedepend may not understand. Remove # the object too, otherwise makedepend will parse it as a source file. -arch) eat=yes ;; -*|$object) ;; *) set fnord "$@" "$arg"; shift ;; esac done obj_suffix=`echo "$object" | sed 's/^.*\././'` touch "$tmpdepfile" ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" rm -f "$depfile" cat < "$tmpdepfile" > "$depfile" sed '1,2d' "$tmpdepfile" | tr ' ' ' ' | \ ## Some versions of the HPUX 10.20 sed can't process this invocation ## correctly. Breaking it into two sed invocations is a workaround. sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" rm -f "$tmpdepfile" "$tmpdepfile".bak ;; cpp) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi # Remove `-o $object'. IFS=" " for arg do case $arg in -o) shift ;; $object) shift ;; *) set fnord "$@" "$arg" shift # fnord shift # $arg ;; esac done "$@" -E | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' | sed '$ s: \\$::' > "$tmpdepfile" rm -f "$depfile" echo "$object : \\" > "$depfile" cat < "$tmpdepfile" >> "$depfile" sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" rm -f "$tmpdepfile" ;; msvisualcpp) # Important note: in order to support this mode, a compiler *must* # always write the preprocessed file to stdout. "$@" || exit $? # Remove the call to Libtool. if test "$libtool" = yes; then while test "X$1" != 'X--mode=compile'; do shift done shift fi IFS=" " for arg do case "$arg" in -o) shift ;; $object) shift ;; "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") set fnord "$@" shift shift ;; *) set fnord "$@" "$arg" shift shift ;; esac done "$@" -E 2>/dev/null | sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" rm -f "$depfile" echo "$object : \\" > "$depfile" sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile" echo " " >> "$depfile" sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" rm -f "$tmpdepfile" ;; msvcmsys) # This case exists only to let depend.m4 do its work. It works by # looking at the text of this script. This case will never be run, # since it is checked for above. exit 1 ;; none) exec "$@" ;; *) echo "Unknown depmode $depmode" 1>&2 exit 1 ;; esac exit 0 # Local Variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: fakeroot-ng-0.18/process.cpp0000644000175000017500000004210412076452015014237 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include #include "syscalls.h" #include "arch/platform.h" #include "process.h" #include "chroot.h" // XXX // Not implemented functions: // acct bool sys_fork( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // XXX It is not clear whether we should lock the shared memory while in this call. // PROC_MEM_LOCK(); if( ptlib_fork_enter( pid, sc_num, state->mem->get_shared(), state->mem->get_loc(), state->saved_state, state->context_state+1 ) ) { state->state=pid_state::RETURN; } else { state->state=pid_state::REDIRECT2; } state->context_state[0]=0; } else if( state->state==pid_state::RETURN || state->state==pid_state::REDIRECT2 ) { pid_t newpid; if( ptlib_fork_exit( pid, &newpid, state->saved_state, state->context_state+1 ) && newpid>0 ) { handle_new_process( pid, newpid ); } state->state=pid_state::NONE; } return true; } bool sys_vfork( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { sys_fork( sc_num, pid, state ); state->context_state[0]=NEW_PROCESS_SAME_VM; // XXX Is this a Linux specific thing? } else { sys_fork( sc_num, pid, state ); } return true; } #ifdef SYS_clone bool sys_clone( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { state->state=pid_state::RETURN; // Need to mark context_state[0] based on the type of new process being created state->context_state[0]=0; int_ptr flags=ptlib_get_argument( pid, 1 ); if( (flags&(CLONE_PARENT|CLONE_THREAD))!=0 ) state->context_state[0]|=NEW_PROCESS_SAME_PARENT; if( (flags&CLONE_FS)!=0 ) state->context_state[0]|=NEW_PROCESS_SAME_ROOT; if( (flags&CLONE_FILES)!=0 ) state->context_state[0]|=NEW_PROCESS_SAME_FD; if( (flags&CLONE_VM)!=0 ) state->context_state[0]|=NEW_PROCESS_SAME_VM; if( (flags&CLONE_PTRACE)!=0 ) state->context_state[0]|=NEW_PROCESS_SAME_DEBUGGER; dlog(PID_F": clone called with flags %lx\n", pid, (unsigned long)flags ); // Whatever it originally was, add a CLONE_PTRACE to the flags so that we remain in control flags|=CLONE_PTRACE; flags&=~CLONE_UNTRACED; // Reset the UNTRACED flag ptlib_set_argument( pid, 1, flags ); } else if( state->state==pid_state::RETURN ) { // Was the call successful? state->state=pid_state::NONE; if( ptlib_success( pid, state->orig_sc ) ) { pid_t newpid=(pid_t)ptlib_get_retval( pid ); dlog(PID_F": clone succeeded, new process " PID_F "\n", pid, newpid ); handle_new_process( pid, newpid ); } else { dlog(PID_F": clone failed: %s\n", pid, strerror( ptlib_get_error( pid, state->orig_sc ) ) ); } } return true; } #endif // SYS_CLONE // Function interface is different - returns an extra bool to signify whether to send a trap after the call // context_state[0] is state machine: // 0 - just returned from execve // 1 - got a SIGTRAP after execve // if context_state[1] is not 0, force error on syscall bool sys_execve( int sc_num, pid_t pid, pid_state *state, bool &trap_after_call ) { trap_after_call=false; if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[1]=0; // Don't force error by default if( log_level>0 ) { char cmd[PATH_MAX]; ptlib_get_string( pid, ptlib_get_argument( pid, 1 ), cmd, sizeof(cmd) ); dlog("execve: " PID_F " calling execve for executing %s\n", pid, cmd ); dlog(NULL); } if( chroot_is_chrooted( state ) ) { if( !chroot_translate_param( pid, state, 1, true, true ) ) { // We had an error translating the file name - pass the error on state->context_state[1]=errno; ptlib_set_syscall( pid, PREF_NOP ); // REDIRECT2 is set anyways } } // On some platforms "execve" returns, when successful, with SYS_restart_syscall or some such thing state->state=pid_state::REDIRECT2; state->context_state[0]=0; } else if( state->state==pid_state::REDIRECT2 ) { if( state->context_state[0]==0 ) { // Execve returned state->state=pid_state::NONE; if( ptlib_success( pid, sc_num ) && state->context_state[1]==0 ) { dlog("execve: " PID_F " successfully execed a new command\n", pid ); // All memory allocations performed before the exec are now null and void state->mem=ref_count(new pid_state::process_memory); #if PTLIB_TRAP_AFTER_EXEC // The platform sends a SIGTRAP to the process after a successful execve, which results in us thinking it was // a syscall. We need to absorb it state->state=pid_state::REDIRECT2; state->context_state[0]=1; if( state->trace_mode==TRACE_SYSCALL ) { // We are not in the "NONE" state, but the syscall is over. Tell parent to trap trap_after_call=true; } #endif } else if( state->context_state[1]!=0 ) { dlog("execve: " PID_F " chroot translation forced error on us: %s\n", pid, strerror(state->context_state[1]) ); ptlib_set_error( pid, state->orig_sc, state->context_state[1] ); } else { dlog("execve: " PID_F " failed with error %s\n", pid, strerror(ptlib_get_error(pid, sc_num)) ); } } else { state->state=pid_state::NONE; dlog("execve: " PID_F " absorbed dummy SIGTRAP after successful execve\n", pid ); // If the trace mode is not SYSCALL, the post handling will not generate a TRACE. If PTLIB_TRAP_AFTER_EXEC is set, // a trace is required, however, even if not in TRACE_SYSCALL trap_after_call=true; } } return true; } bool sys_sigreturn( int sc_num, pid_t pid, pid_state *state ) { // This is not a function call. In particular, this "not function call" may wreak haevoc in our state keeping, and // thus the special handling if( state->state==pid_state::NONE ) { // Upon syscall exit, at least on Linux, the syscall is "-1" state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; } return true; } bool sys_setsid( int sc_num, pid_t pid, pid_state *state ) { // We do not do any actual manipulation on the syscall. We just keep track over the process' session ID if( state->state==pid_state::NONE ) { state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; if( ptlib_success( pid, sc_num ) ) { state->session_id=pid; } } return true; } // This call needs to be emulated under one of two conditions: // 1. Platform does not support "wait" by parent on a debugged child (PTLIB_PARENT_CAN_WAIT=0) // 2. The parent is a debugger (we are emulating the entire ptrace interface) // // Of course, with PTRACE_TRACEME, it is possible that the process not have a debugee when it // starts the wait, but does have one by the time wait should return. We therefor emulate the // entire system call, always :-( static bool real_wait4( int sc_num, pid_t pid, pid_state *state, pid_t param1, int *param2, int param3, void *param4 ) { if( state->state==pid_state::NONE ) { state->context_state[0]=param1; // pid state->context_state[1]=(int_ptr)param2; // status state->context_state[2]=param3; // options state->context_state[3]=(int_ptr)param4; // rusage dlog("wait4: %d num debugees: %d num children: %d, queue %s\n", pid, state->num_debugees, state->num_children, state->waiting_signals.empty()?"is empty":"has signals" ); // Test whether the (emulated) call should fail // XXX This is nowhere near the exhustive tests we need to do. We only aim to emulate strace and ourselves at this point in time if( state->num_children!=0 || state->num_debugees!=0 || !state->waiting_signals.empty() ) { // Only wait if there was no error state->state=pid_state::WAITING; } else { // Set an ECHILD return code state->state=pid_state::REDIRECT2; ptlib_set_syscall( pid, PREF_NOP ); // NOP call state->context_state[0]=-ECHILD; } } else if( state->state==pid_state::REDIRECT2 ) { // We may get here under two conditions. // Either the wait was performed by us and a NOP was carried out, in which case the syscall is going to be PREF_NOP // and context_state[0] contains the desired return code (negative for error) // Or // A function substancially similar to wait was carried out, in which case context_state[0] contains a backup of the original // content of the fourth parameter register, which may have not been used by the original syscall if it was not wait4 if( sc_num==PREF_NOP ) { // Performed NOP - set return codes if( ((long)state->context_state[0])>=0 ) ptlib_set_retval( pid, state->context_state[0] ); else ptlib_set_error( pid, state->orig_sc, -state->context_state[0] ); ptlib_set_syscall( pid, state->orig_sc ); } else { // If an actual wait syscall was carried out, we may need to restore the original content of argument 4 ptlib_set_argument( pid, 4, state->context_state[0] ); } ptlib_set_syscall( pid, state->orig_sc ); state->state=pid_state::NONE; } if( state->state==pid_state::WAITING ) { if( !state->waiting_signals.empty() ) { // Let's see what was asked for pid_t wait_pid=(pid_t)state->context_state[0]; std::list::iterator child=state->waiting_signals.begin(); assert(child!=state->waiting_signals.end()); pid_state *child_state=NULL; if( wait_pid<-1 ) { // We are looking for process with session id= -pid child_state=lookup_state(child->pid()); while( child!=state->waiting_signals.end() && child_state->session_id!=-wait_pid ) { if( (++child)!=state->waiting_signals.end() ) { child_state=lookup_state(child->pid()); assert(child_state!=NULL); } } } else if( wait_pid==-1 ) { // Wait for anything. Just leave child as it is } else if( wait_pid==0 ) { // Wait for session_id==parent's child_state=lookup_state(child->pid()); while( child!=state->waiting_signals.end() && child_state->session_id!=state->session_id ) { if( (++child)!=state->waiting_signals.end() ) { child_state=lookup_state(child->pid()); assert(child_state!=NULL); } } } else { // Wait for exact match while( child!=state->waiting_signals.end() && child->pid()!=wait_pid ) ++child; } if( child!=state->waiting_signals.end() ) { // We have what to report if( child_state==NULL ) { child_state=lookup_state(child->pid()); assert(child_state!=NULL); } assert( child_state->state!=pid_state::INIT ); if( child_state->state==pid_state::ZOMBIE ) { // We can dispense with the pid entry delete_state(child->pid()); dlog("%s: Child " PID_F " removed from process table\n", __func__, child->pid() ); child_state=NULL; } // allow the syscall to return // Fill in the rusage if( ((void *)state->context_state[3])!=NULL ) ptlib_set_mem( pid, &child->usage(), state->context_state[3], sizeof(child->usage()) ); // Is this a report about a terminated program? if( !child->debugonly() ) { // If the parent never carried out the actual "wait", the child will become a zombie // We turn the syscall into a waitpid with the child's pid explicitly given #ifdef SYS_wait4 ptlib_set_syscall( pid, SYS_wait4 ); #else ptlib_set_syscall( pid, SYS_waitpid ); #endif state->saved_state[0]=(void *)ptlib_get_argument( pid, 4 ); // Save the fourth argument ptlib_set_argument( pid, 1, child->pid() ); ptlib_set_argument( pid, 2, state->context_state[1] ); ptlib_set_argument( pid, 3, state->context_state[2] ); ptlib_set_argument( pid, 4, state->context_state[3] ); } else { // We need to explicitly set all the arguments if( ((void *)state->context_state[1])!=NULL ) ptlib_set_mem( pid, &child->status(), state->context_state[1], sizeof(child->status()) ); ptlib_set_syscall( pid, PREF_NOP ); state->context_state[0]=child->pid(); } state->waiting_signals.erase( child ); state->state=pid_state::REDIRECT2; } else { dlog("wait4: " PID_F " hanged in wait for %d\n", pid, wait_pid ); } } if( state->state==pid_state::WAITING && (state->context_state[2]&WNOHANG)!=0 ) { // Client asked never to hang state->state=pid_state::REDIRECT2; ptlib_set_syscall( pid, PREF_NOP ); state->context_state[0]=0; } } return state->state!=pid_state::WAITING; } bool sys_wait4( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { pid_t param1=(pid_t)ptlib_get_argument(pid, 1); // pid int *param2=(int *)ptlib_get_argument(pid, 2); // status int param3=ptlib_get_argument(pid, 3); // options void *param4=(void *)ptlib_get_argument(pid, 4); // rusage return real_wait4( sc_num, pid, state, param1, param2, param3, param4 ); } else { return real_wait4( sc_num, pid, state, 0, NULL, 0, NULL ); } } // We just set the variables and let wait4 handle our case bool sys_waitpid( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { pid_t param1=ptlib_get_argument(pid, 1); // pid int *param2=(int *)ptlib_get_argument(pid, 2); // status int param3=ptlib_get_argument(pid, 3); // options return real_wait4( sc_num, pid, state, param1, param2, param3, NULL ); } else { return real_wait4( sc_num, pid, state, 0, NULL, 0, NULL ); } } // We want to prevent the process from killing us bool sys_kill( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { state->state=pid_state::RETURN; if( ((pid_t)ptlib_get_argument( pid, 1 ))==getpid() ) { // Process tried to send us a signal. Can't allow that state->state=pid_state::REDIRECT2; ptlib_set_syscall( pid, PREF_NOP); } } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; ptlib_set_error( pid, state->orig_sc, EPERM ); } return true; } fakeroot-ng-0.18/daemon.cpp0000644000175000017500000004260412130340173014021 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include "daemon.h" #include #include #include #include #include #include #include #include #include #include #include #if HAVE_SYS_PRCTL_H #include #endif #include "exceptions.h" #include "arch/platform.h" #include "log.h" #include "parent.h" #include "file_lie.h" template class ipcMessage { T _payload; unsigned char _ancillary_buffer[CMSG_SPACE(sizeof(struct ucred))]; struct iovec _iovec; struct msghdr _header; struct ucred *_credentials; public: ipcMessage() : _credentials(NULL) { memset( &_payload, 0, sizeof(T) ); memset( &_header, 0, sizeof(_header) ); _iovec.iov_base=&_payload; _iovec.iov_len=sizeof(T); _header.msg_iov=&_iovec; _header.msg_iovlen=1; _header.msg_control=_ancillary_buffer; } void recv( int fd ) { _header.msg_controllen=sizeof(_ancillary_buffer); ssize_t num_read=recvmsg( fd, &_header, 0 ); if( num_read<0 ) throw errno_exception("Read failed"); // Socket closed? if( num_read==0 ) { throw daemonCtrl::remote_hangup_exception(); } if( static_cast(num_read)cmsg_level==SOL_SOCKET && cmsg->cmsg_type==SCM_CREDENTIALS ) _credentials=(struct ucred *)CMSG_DATA(cmsg); } } void send( int fd ) { _header.msg_controllen=sizeof(_ancillary_buffer); struct cmsghdr *cmsg=CMSG_FIRSTHDR(&_header); cmsg->cmsg_level=SOL_SOCKET; cmsg->cmsg_type=SCM_CREDENTIALS; cmsg->cmsg_len=CMSG_LEN(sizeof(struct ucred)); _header.msg_controllen=cmsg->cmsg_len; _credentials=(struct ucred *)CMSG_DATA(cmsg); _credentials->pid=getpid(); _credentials->uid=getuid(); _credentials->gid=getgid(); ssize_t num_written=sendmsg( fd, &_header, 0 ); if( num_written<0 ) throw errno_exception("Send failed"); if( static_cast(num_written)() { return &_payload; } const T * operator->() const { return &_payload; } const struct ucred *credentials() const { if( _credentials==NULL ) throw detailed_exception("Credentials not set on message"); return _credentials; } }; static std::unique_ptr daemon_process; daemonCtrl::daemonCtrl(const char *state_file_path, bool nodetach) : daemon_socket(-1), daemon_pid(0) { if( state_file_path==NULL ) { // Anonymous daemon. Always needs to start daemon_socket = daemonProcess::create( nodetach ); set_client_sock_options(daemon_socket); cmd_reserve(); } else { connect( state_file_path ); while( daemon_socket<0 ) { daemonProcess::create( state_file_path, nodetach ); connect( state_file_path ); } } } daemonCtrl::~daemonCtrl() { if( daemon_socket>=0 ) { close(daemon_socket); daemon_socket=-1; } } void daemonCtrl::connect( const char * state_file_path ) { int client_socket=socket( PF_UNIX, SOCK_SEQPACKET, 0 ); if( client_socket==-1 ) { // Couldn't create a socket throw errno_exception( "Unix socket creation error" ); } sockaddr_un sa; sa.sun_family=AF_UNIX; snprintf( sa.sun_path, sizeof(sa.sun_path), "%s.run", state_file_path ); if( ::connect(client_socket, (const struct sockaddr *) &sa, sizeof(sa) )<0 ) { close( client_socket ); // No daemon running return; } try { set_client_sock_options(client_socket); daemon_socket=client_socket; cmd_reserve(); } catch( const errno_exception &exception ) { dlog("Daemon connect failed: %s (%s)", exception.what(), exception.get_error_message() ); close( client_socket ); daemon_socket=-1; } catch( const std::exception &exception ) { dlog("Daemon connect failed: %s", exception.what()); close( client_socket ); daemon_socket=-1; throw; } catch( ... ) { close( client_socket ); daemon_socket=-1; throw; } } void daemonCtrl::send_std_cmd( commands command, ipcMessage &response ) const { ipcMessage message; message->command=command; message.send( daemon_socket ); response.recv( daemon_socket ); if( response->command!=command ) throw detailed_exception( "Response received for different command than request" ); if( response->result>0 ) { errno=response->result; throw errno_exception( "Command failed" ); } } void daemonCtrl::set_client_sock_options( int fd ) { fcntl( fd, F_SETFD, FD_CLOEXEC ); int passcred=true; setsockopt( fd, SOL_SOCKET, SO_PASSCRED, &passcred, sizeof(passcred) ); // XXX Check return type? } void daemonCtrl::cmd_reserve() { ipcMessage response; send_std_cmd( CMD_RESERVE, response ); daemon_pid=response.credentials()->pid; } void daemonCtrl::cmd_attach() { ipcMessage response; try { #if HAVE_DECL_PR_SET_PTRACER // We need to tell the kernel it is okay for the debugger to attach to us assert( daemon_pid!=0 ); prctl( PR_SET_PTRACER, daemon_pid, 0, 0, 0 ); #endif // HAVE_DECL_PR_SET_PTRACER send_std_cmd( CMD_ATTACH, response ); } catch( const errno_exception &exception ) { errno=exception.get_error(); throw errno_exception( "Ptrace attach failed" ); } } daemonProcess::daemonProcess( int session_fd ) : max_fd(0) { unique_fd session(session_fd); set_client_sock_options(session_fd); FD_ZERO( &file_set ); register_session( session ); } daemonProcess::daemonProcess( const std::string &path, unique_fd &state_file, unique_fd &master_fd ) : state_path( path ), master_socket( std::move(master_fd) ), state_fd( std::move(state_file) ) { FILE *state_file_handle=fdopen( dup(state_fd.get()), "rt" ); load_map( state_file_handle ); fclose(state_file_handle); recalc_select_mask(); } daemonProcess::~daemonProcess() { if( state_path.length()>0 ) { std::string tmp_path( state_path ); tmp_path+=".tmp"; FILE * new_state = fopen( tmp_path.c_str(), "wt" ); if( new_state==NULL ) { dlog("Failed to open state file for saving: %s\n", strerror(errno) ); return; } save_map( new_state ); fclose( new_state ); if( rename( tmp_path.c_str(), state_path.c_str() )<0 ) { dlog("Rename of temporary file failed: %s\n", strerror(errno) ); } unlink((state_path+".run").c_str()); } } void daemonProcess::register_session( unique_fd &fd ) { dlog("Added session %d\n", fd.get()); session_fds.push_back( std::move(fd) ); recalc_select_mask(); } int daemonProcess::create( bool nodetach ) { int sockets[2]={-1, -1}; // 0 - daemon side, 1 - client side if( socketpair( PF_UNIX, SOCK_SEQPACKET, 0, sockets )<0 ) throw errno_exception("Child socket creation error"); try { if( daemonize( nodetach, sockets[0] ) ) { // We are the daemon daemon_process=std::unique_ptr(new daemonProcess(sockets[0])); daemon_process->start(); daemon_process.reset(); exit(0); } // We are the "child" (technically - parent) // Close the daemon side socket close(sockets[0]); sockets[0]=-1; } catch( ... ) { // It is very hard to get C++ wrappers to play nice with the wierd semanitcs of "fork", so we close these // manually. if( sockets[0]>=0 ) close( sockets[0] ); close( sockets[1] ); throw; } return sockets[1]; } void daemonProcess::create( const char *state_file_path, bool nodetach ) { // Try to obtain the lock unique_fd state_file( ::open( state_file_path, O_CREAT|O_RDWR, 0666 ), "State file open failed" ); if( !state_file.flock( LOCK_EX|LOCK_NB ) ) // Someone else is holding the lock return; // We want to return from this function only after the listening socket already exists and is bound, to avoid a race unique_fd master_socket( ::socket( PF_UNIX, SOCK_SEQPACKET, 0 ), "Failed to create master socket" ); // Make the path canonical char *state_realpath=realpath(state_file_path, NULL); std::string absolute_state_path(state_realpath); free( state_realpath ); sockaddr_un sa; sa.sun_family=AF_UNIX; snprintf( sa.sun_path, sizeof(sa.sun_path), "%s.run", absolute_state_path.c_str() ); // Since we are holding the lock, we know no one else is listening unlink( sa.sun_path ); if( bind( master_socket.get(), (const struct sockaddr *) &sa, sizeof(sa) )<0 ) throw errno_exception( "Failed to bind master socket" ); listen( master_socket.get(), 10 ); // At this point the socket is bound to the correct path on the file system, and is listening. We can safely // fork the daemon and return control to the debugee if( daemonize( nodetach, state_file.get(), master_socket.get() ) ) { // We are the daemon daemon_process=std::unique_ptr(new daemonProcess( absolute_state_path, state_file, master_socket )); daemon_process->start(); daemon_process.reset(); exit(0); } // We are the "child" (technically - parent) - nothing more to do } bool daemonProcess::daemonize( bool nodetach, int skip_fd1, int skip_fd2 ) { pid_t debugger=fork(); if( debugger<0 ) throw errno_exception("Failed to create debugger process"); if( debugger!=0 ) { // We are the parent, which is actually the child (debugee) int status; if( waitpid( debugger, &status, 0 )<0 ) throw errno_exception("waitpid on child failed"); if( !WIFEXITED(status) || WEXITSTATUS(status)!=0 ) { dlog("Child exit with result %x", status); throw detailed_exception( "Child process exit with error - cannot start daemon" ); } return false; } // We are the child - we want to be the grandchild debugger=fork(); if( debugger<0 ) { dlog("Failed to fork grandchild: %s", strerror(errno)); _exit(1); } if( debugger!=0 ) { // Still the child - exit without any cleanup _exit(0); } // We are the grandchild - complete the daemonization setsid(); dlog("Debugger started\n"); if( !nodetach ) { // Close all open file descriptors except our skip_fds and the debug_log (if it exists) // Do not close the file handles, nor chdir to root, if in debug mode. This is so that more debug info // come out and that core can be dumped int fd=get_log_fd(); int fd_limit=getdtablesize(); for( int i=0; i0); } while(repeat); dlog("Daemon done\n"); } bool daemonProcess::handle_request( const sigset_t *sigmask, bool existing_children ) { bool ret=session_fds.size()>0; fd_set read_set=file_set; fd_set except_set=file_set; struct timespec timeout; timeout.tv_sec=0; timeout.tv_nsec=0; // Wait nothing if we are about to exit, indefinitely if we have reason to stay int result=pselect( max_fd, &read_set, NULL, &except_set, (ret || existing_children) ? NULL : &timeout, sigmask ); if( result<0 ) return ret; if( master_socket && FD_ISSET( master_socket.get(), &read_set ) ) { result--; handle_new_connection(); ret=true; } if( result>=0 ) { auto i=session_fds.begin(); while( i!=session_fds.end() ) { auto current=i; // handling might erase i, so we make sure to perform the loop increment before everything else ++i; try { if( FD_ISSET( current->get(), &read_set ) || FD_ISSET( current->get(), &except_set ) ) handle_connection_request( current ); } catch( const errno_exception &except ) { dlog("Read from session socket %d failed: %s (%s)", current->get(), except.what(), except.get_error_message()); } catch( const daemonCtrl::terminal_error &except ) { close_session(current); } } } return ret; } void daemonProcess::set_client_sock_options( int fd ) { daemonCtrl::set_client_sock_options(fd); fcntl( fd, F_SETFL, O_NONBLOCK ); } void daemonProcess::handle_new_connection() { assert(master_socket); unique_fd connection_fd( ::accept( master_socket.get(), NULL, NULL ) ); if( !connection_fd ) { dlog( "Accept failed: %s", strerror(errno) ); return; } set_client_sock_options( connection_fd.get() ); session_fds.push_back(std::move(connection_fd)); dlog("Received new session, socket #%d", connection_fd.get()); recalc_select_mask(); } void daemonProcess::handle_connection_request( decltype(session_fds)::iterator & element ) { ipcMessage request; try { request.recv( element->get() ); switch( request->command ) { case daemonCtrl::CMD_RESERVE: handle_cmd_reserve( element, request ); break; case daemonCtrl::CMD_ATTACH: handle_cmd_attach( element, request ); break; default: dlog("Session %d sent unknown command %d\n", element->get(), request->command); close_session(element); }; } catch( const daemonCtrl::remote_hangup_exception &exception ) { dlog("Session %d hung up\n", element->get()); close_session(element); } } void daemonProcess::handle_cmd_reserve( decltype(session_fds)::iterator & element, const ipcMessage &message ) { ipcMessage response; response->command=daemonCtrl::CMD_RESERVE; response->result=0; response.send(element->get()); } void daemonProcess::handle_cmd_attach( decltype(session_fds)::iterator & element, const ipcMessage &message ) { ipcMessage response; response->command=daemonCtrl::CMD_ATTACH; try { attach_debugger( message.credentials()->pid ); response->result=0; } catch( const errno_exception &exception ) { response->result=exception.get_error(); } response.send(element->get()); } void daemonProcess::recalc_select_mask() { FD_ZERO(&file_set); max_fd=-1; for( auto i=session_fds.begin(); i!=session_fds.end(); ++i ) { FD_SET(i->get(), &file_set); if( i->get()>max_fd ) max_fd=i->get(); } if( master_socket ) { FD_SET(master_socket.get(), &file_set); if( master_socket.get()>max_fd ) max_fd=master_socket.get(); } max_fd++; } void daemonProcess::close_session( decltype(session_fds)::iterator & element ) { dlog("Session %d closed\n", element->get()); session_fds.erase(element); recalc_select_mask(); } fakeroot-ng-0.18/README0000644000175000017500000000342712131750746012746 0ustar sunsunWhen building fakeroot-ng, it is recommended that the --with-memdir configure option be used to direct the shared memory files into a directory that resides on a tmpfs file system. On Debian systems, this is typically the /dev/shm directory. Care must be taken, however, that this directory not reside on a file system that is mounted with the noexec flag, or fakeroot-ng will not be able to function properly. This file lists bugs and limitations of fakeroot-ng. There are three lists: SCOPE - areas that are left, on purpose, outside the scope TODO - lists action items that are simply not yet implemented BUGS - lists functions that are implemented, but have known limitations that will be addressed soonish LIMITATIONS - lists limitations either inherent to the technology, or that are outside the scope of coverage intended in the foreseeable future. SCOPE - When switching users, file permissions do not mimic the real system. For files created as part of the fake root environment, all access is "root" access, regardless of the file's true permissions. TODO - Wider support for "old" syscalls (16 bit getuid, 32bit stat etc.) - Multithreaded debugger - Redirect opens of "character devices" to real device with same major/minor. - In chroot, the actual interpreter file (ld-linux for ELF executable) is searched for in the real root, rather than in the chrooted jail. BUGS - The "wait" type syscalls are only emulated enough to allow two specific debuggers to run: fakeroot-ng and strace - Poor handling of multithreaded programs - mostly solved - Poor handling of 32 bit programs on X86_64 - Files created inside SGID directories do not inherit their gid from the directory. LIMITATIONS - Program has limited access to the fakeroot-ng controlled memory inside the program's address space fakeroot-ng-0.18/refcount.h0000644000175000017500000000276611005554165014065 0ustar sunsun#ifndef REF_COUNT_H #define REF_COUNT_H // Reference counting smart pointer template class ref_count { struct capsule { T *data; int count; }; capsule *p; void release() { if( p!=NULL && (--p->count)==0 ) { delete p->data; delete p; } p=NULL; } public: ref_count() : p(NULL) { } ref_count( const ref_count &rhs ) : p(rhs.p) { if( p!=NULL ) { p->count++; } } explicit ref_count( T *data ) : p(new capsule) { if( p!=NULL ) { p->data=data; p->count=1; } else { // Our allocation failed, but the called relied on us to release their pointer when we're done delete data; } } ~ref_count() { release(); } ref_count &operator=( const ref_count &rhs ) { release(); p=rhs.p; if( p!=NULL ) { p->count++; } return *this; } operator T* () { return p!=NULL ? p->data : NULL; } operator const T*() const { return p!=NULL ? p->data : NULL; } T *operator ->() { return *this; } const T *operator ->() const { return *this; } T &operator *() { return *static_cast(*this); } const T &operator *() const { return *static_cast(*this); } }; #endif // REF_COUNT_H fakeroot-ng-0.18/ptrace.cpp0000644000175000017500000002711212076452015014041 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include "syscalls.h" #include "arch/platform.h" // Retruns true of the specified pid has permission to perform a ptrace operation static bool verify_permission( pid_t pid, pid_state *state ) { pid_t traced=(pid_t)state->context_state[1]; // First, find out whether the pid we work on even exists pid_state *child_state=lookup_state( traced ); if( child_state==NULL || child_state->debugger!=pid ) { dlog("ptrace verify_permission: %d failed permission - not the debugger for " PID_F "\n", pid, traced); errno=ESRCH; return false; } if( child_state->trace_mode!=TRACE_STOPPED1 && child_state->trace_mode!=TRACE_STOPPED2 ) { dlog("ptrace verify_permission: %d failed permission - " PID_F " is not stopped\n", pid, traced); errno=ESRCH; return false; } return true; } static bool begin_trace( pid_t debugger, pid_t child ) { pid_state *child_state=lookup_state( child ); pid_state *parent_state=lookup_state( debugger ); if( child_state==NULL || parent_state==NULL || child_state->debugger!=0 ) { dlog("begin_trace: %d Failed to start trace for " PID_F ": child_state=%p, parent_state=%p", debugger, child, child_state, parent_state ); if( child_state!=NULL ) { dlog("child_state debugger=" PID_F, child_state->debugger); } dlog("\n"); errno=EPERM; return false; } child_state->debugger=debugger; child_state->trace_mode=PTRACE_CONT; parent_state->num_debugees++; return true; } static void real_handle_cont( pid_t pid, pid_state *state ) { pid_t child=(pid_t)state->context_state[1]; pid_state *child_state=lookup_state( child ); __ptrace_request req=(__ptrace_request)state->context_state[0]; if( req==PTRACE_CONT ) { child_state->trace_mode|=TRACE_CONT; dlog("ptrace: %d PTRACE_CONT(" PID_F ")\n", pid, child ); } else if( req==PTRACE_SYSCALL ) { child_state->trace_mode|=TRACE_SYSCALL; dlog("ptrace: %d PTRACE_SYSCALL(" PID_F ")\n", pid, child ); } else if( req==PTRACE_DETACH ) { child_state->trace_mode&=TRACE_MASK2; } else { // Wrong mode for calling this function! } long rc=0; if( (child_state->trace_mode&TRACE_MASK2)==TRACE_STOPPED1 ) { dlog("handle_cont_syscall: " PID_F " process " PID_F " was in pre-syscall hook\n", pid, child ); // Need to restart the syscall int status=child_state->context_state[1]; PTLIB_WAIT_RET wait_state=(PTLIB_WAIT_RET)child_state->context_state[0]; long ret=ptlib_get_syscall( child ); int sig=process_sigchld( child, wait_state, status, ret ); // If our processing requested no special handling, use the signal requested by the debugger if( sig==0 ) { sig=(int)state->context_state[3]; } if( sig>=0 ) { rc=ptlib_continue(PTRACE_SYSCALL, child, sig); } } else if( (child_state->trace_mode&TRACE_MASK2)==TRACE_STOPPED2 ) { dlog("handle_cont_syscall: " PID_F " process " PID_F " was in post-syscall hook\n", pid, child ); child_state->trace_mode&=TRACE_MASK1; rc=ptlib_continue( PTRACE_SYSCALL, child, (int)state->context_state[3] ); } else { // Our child was not stopped (at least, by us) // This is an internal inconsistency dlog("handle_cont_syscall: " PID_F " process " PID_F " was started with no specific state (%x)\n", pid, child, child_state->trace_mode ); dlog(NULL); rc=-1; } if( rc!=-1 ) { dlog("ptrace: %d request successful\n", pid ); ptlib_set_retval( pid, rc ); } else { ptlib_set_error( pid, state->orig_sc, errno ); dlog("ptrace: %d request failed: %s\n", pid, strerror(errno) ); } } static void handle_cont_syscall( pid_t pid, pid_state *state ) { if( verify_permission( pid, state ) ) { real_handle_cont( pid, state ); } else { ptlib_set_error( pid, state->orig_sc, errno ); } } static bool handle_detach( pid_t pid, pid_state *state ) { if( verify_permission( pid, state ) ) { dlog("ptrace: %d PTRACE_DETACH(" PID_F ")\n", pid, (pid_t)state->context_state[1]); pid_state *child_state=lookup_state((pid_t)state->context_state[1]); child_state->debugger=0; state->num_debugees--; child_state->trace_mode&=TRACE_MASK2; // Call the cont handler to make sure the debuggee is runing again real_handle_cont( pid, state ); return true; } else { ptlib_set_error( pid, state->orig_sc, errno ); return false; } } static void handle_kill( pid_t pid, pid_state *state ) { pid_t child=(pid_t)state->context_state[1]; if( verify_permission( pid, state ) ) { dlog("handle_kill: %d is sending a kill to " PID_F "\n", pid, child ); ptlib_continue(PTRACE_KILL, child, 0); ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, errno ); dlog("handle_kill: %d tried to kill " PID_F ": %s\n", pid, child, strerror(errno)); } } static void handle_peek_data( pid_t pid, pid_state *state ) { pid_t child=(pid_t)state->context_state[1]; if( verify_permission( pid, state ) ) { errno=0; long data=ptrace( (__ptrace_request)state->context_state[0], child, state->context_state[2], 0 ); if( data!=-1 || errno==0 ) { dlog("handle_peek_data: %d is peeking data from " PID_F " at address %p\n", pid, child, (void*)state->context_state[2] ); // Write the result where applicable // XXX This may be a Linux only semantics - pass addres to write result to as "data" argument data=ptlib_set_mem( pid, &data, state->context_state[3], sizeof(data)); if( data!=-1 ) { ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, errno ); dlog("handle_peek_data: Our own poke failed: %s\n", strerror(errno) ); } } } else { ptlib_set_error( pid, state->orig_sc, errno ); dlog("handle_peek_data: %d tried get data from " PID_F ": %s\n", pid, child, strerror(errno)); } } static void handle_poke_data( pid_t pid, pid_state *state ) { pid_t child=(pid_t)state->context_state[1]; if( verify_permission( pid, state ) && ptrace( (__ptrace_request)state->context_state[0], child, state->context_state[2], state->context_state[3] )==0 ) { dlog("handle_poke_data: %d is pokeing data in " PID_F " at address %p\n", pid, child, (void*)state->context_state[2] ); ptlib_set_retval( pid, 0 ); } else { ptlib_set_error( pid, state->orig_sc, errno ); dlog("handle_poke_data: %d tried push data to " PID_F ": %s\n", pid, child, strerror(errno)); } } bool sys_ptrace( int sc_num, pid_t pid, pid_state *state ) { bool ret=true; if( state->state==pid_state::NONE ) { state->context_state[0]=ptlib_get_argument( pid, 1 ); // request state->context_state[1]=ptlib_get_argument( pid, 2 ); // pid state->context_state[2]=ptlib_get_argument( pid, 3 ); // addr state->context_state[3]=ptlib_get_argument( pid, 4 ); // data dlog("ptrace: " PID_F " ptrace( %d, " PID_F ", %p, %p )\n", pid, (int)state->context_state[0], (pid_t)state->context_state[1], (void*)state->context_state[2], (void*)state->context_state[3] ); ptlib_set_syscall( pid, PREF_NOP ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; // Let's see what whether we need to succeed switch( state->context_state[0] ) { case PTRACE_TRACEME: if( begin_trace( state->parent, pid ) ) { dlog("ptrace: %d PTRACE_TRACEME parent " PID_F "\n", pid, state->parent ); ptlib_set_retval( pid, 0 ); } else { dlog("ptrace: %d PTRACE_TRACEME failed %s\n", pid, strerror(errno) ); ptlib_set_error( pid, state->orig_sc, errno ); } break; case PTRACE_ATTACH: if( begin_trace( pid, (pid_t)state->context_state[1] ) ) { dlog("ptrace: " PID_F " PTRACE_ATTACH(" PID_F ") succeeded\n", pid, (pid_t)state->context_state[1] ); ptlib_set_retval( pid, 0 ); } else { dlog("ptrace: " PID_F " PTRACE_ATTACH(" PID_F ") failed %s\n", pid, (pid_t)state->context_state[1], strerror(errno) ); ptlib_set_error( pid, state->orig_sc, errno ); } break; case PTRACE_PEEKTEXT: case PTRACE_PEEKDATA: #if HAVE_PTRACE_PEEKUSER case PTRACE_PEEKUSER: #endif handle_peek_data( pid, state ); break; case PTRACE_POKETEXT: case PTRACE_POKEDATA: #if HAVE_PTRACE_PEEKUSER case PTRACE_POKEUSER: #endif handle_poke_data( pid, state ); break; #if 0 case PTRACE_GETREGS: case PTRACE_GETFPREGS: dlog("ptrace: %d GETREGS not yet implemented\n", pid); ptlib_set_error( pid, state->orig_sc, EINVAL ); break; case PTRACE_SETREGS: case PTRACE_SETFPREGS: dlog("ptrace: %d SETREGS not yet implemented\n", pid); ptlib_set_error( pid, state->orig_sc, EINVAL ); break; case PTRACE_GETSIGINFO: dlog("ptrace: %d GETSIGINFO not yet implemented\n", pid); ptlib_set_error( pid, state->orig_sc, EINVAL ); break; case PTRACE_SETSIGINFO: dlog("ptrace: %d SETSIGINFO not yet implemented\n", pid); ptlib_set_error( pid, state->orig_sc, EINVAL ); break; #endif case PTRACE_SINGLESTEP: // We do not support single step right now ptlib_set_error( pid, state->orig_sc, EINVAL ); dlog("ptrace: " PID_F " tried to call SINGLESTEP on " PID_F "\n", pid, (pid_t)state->context_state[1]); break; case PTRACE_CONT: case PTRACE_SYSCALL: handle_cont_syscall( pid, state ); break; case PTRACE_KILL: handle_kill( pid, state ); break; case PTRACE_DETACH: handle_detach( pid, state ); break; default: dlog("ptrace: " PID_F " Unsupported option %lx\n", pid, state->context_state[0] ); ptlib_set_error(pid, state->orig_sc, EINVAL); break; } ptlib_set_syscall( pid, state->orig_sc ); } return ret; } fakeroot-ng-0.18/NEWS0000644000175000017500000000344012131750746012560 0ustar sunsunAs of version 0.18, a persistent daemon will hang around for a few seconds after the last client has exit, in case a new client comes along for the same database. This makes the performance penalty for using repeated fakeroot-ng commands in a script much lower. The following is now both safe and has reasonable performance: #!/bin/sh -e fakeroot-ng command1 fakeroot-ng command2 fakeroot-ng command3 fakeroot-ng command4 As of version 0.15, fakeroot-ng makes sure that it has complete access to files and directories it creates, even if they "have" no uid read permission. Fakeroot-ng now supports running two independent instances using the same state file, and have the fake image both instances see be synchronized. As of version 0.10, fakeroot-ng now supports the "chroot" system call. Once called, a process will be restriced to a subtree of the entire file system. This applies to almost all system calls. System calls this does not apply to include some old system calls. Also, when an ELF executable (any Linux executable nowadays, for example) is loaded using execve, the kernel analyzes it to see where the dynamic linker resides. usually it is /lib/ld-linux.so.2. Since the kernel is the one doing this analysis, this file is not affected by a chroot. Unfortunately, this is not a trivial problem. ld-linux.so.2 and glibc are very tightly coupled, and it is not possible to combine them across versions. As a result, an attempt, for example, to chroot from a Debian Sid machine into a Debian Sarge chroot will fail with the following error message: /bin/bash: relocation error: /lib/tls/libc.so.6: symbol _dl_starting_up, version GLIBC_PRIVATE not defined in file ld-linux.so.2 with link time reference This is a result of ld-linux from Sid trying to load glibc from Sarge. A solution is being worked on. fakeroot-ng-0.18/fakeroot-ng.man0000644000175000017500000001474312126212254014771 0ustar sunsun.TH FAKEROOT\-NG 1 "April 1, 2013" "Shachar Shemesh" "Fakeroot Next Gen User Manual" .\" Please adjust this date whenever revising the manpage. .SH NAME fakeroot\-ng \- run a command while making it believe it is running as root .SH SYNOPSIS \fBfakeroot\-ng\fP [ \fB\-l\fIlogfile\fP [\fB\-f\fP] ] [ \fB\-p\fIpersist_file\fP ] [\-d] \fIcommand line\fP .SH DESCRIPTION This manual page documents the \fBfakeroot\-ng\fP command. .PP Fakeroot\-ng allows running a process without any change to the permissions, but fooling the process into thinking that it is running with root permissions. This typically involves intercepting certain system calls the process performs and manipulating their results. In order for the effect to be complete enough, previous manipulations have to be remembered, and consistent results returned. .PP The idea behind fakroot\-ng was first implemented by a tool called fakeroot(1). This tool used LD_PRELOAD of the dynamic linking to glibc in order to intercept the system calls. While this approach is very rebust and very platform independent, it does suffer in scope. In particular, certain operations (mostly the open(2) system call) could not be intercepted, which caused emulating other operations (mainly the chroot(2) system call) to not be supported. .PP Fakeroot\-ng strives to fill those gaps by using a totally different technology for system call interception. Instead of using LD_PRELOAD, ptrace(2) is being used. .SH PARAMETERS .TP \fB\-p\fIstate_file\fP Before the first process is being run, loads from \fIstate_file\fP the information needed in order to maintain a consistent view of file permissions and owners across fakeroot\-ng runs. This image is also automatically saved when the last process exists. If more then one instance of fakeroot\-ng is loaded simultaneously, both with the same \fIstate_file\fP, then the two instances will share state and their processes will see the same picture at runtime. .TP \fB\-l\fIlog_file\fP Causes fakeroot\-ng to dump to \fIlog_file\fP internal state and processing information. This is mostly useful for cases where fakeroot\-ng fails to act as expected. .TP \fB-f\fP Causes the log file to be flushed after every print. Guarantees that the important hint as to why the crash happened will be in the actual file, but has non-negligent performance effect. Only has effect if \fB\-l\fP is specified. .TP \fB\-d\fP Tells fakeroot\-ng not to completely daemonize itself. This is mostly useful in case of crashes that cause a core dump, as the debugger would normally change directory to root, which would prevent a core file from being created. .TP \fB\-v\fP Print out the version number and copyright info and exit without doing anything. .TP \fB\-h\fP Print out a short help screen and exit. .SH SIGNALS Sending the ALRM signal to the fakeroot\-ng master process makes it dump to the log a complete list of all tracked processes, along with their parent and current state. This is, mostly, a debugging feature. The signal does nothing if \fB\-l\fP is not active. Please note that no process executes any system calls while this takes place, so this feature essentially freezes all of the debugged processes for a few seconds. .SH ENVIRONMENT VARIABLES AND SHARED MEMORY Some of the communication between fakeroot\-ng and the program being fooled is done through a shared memory mechanism. In order to create it, fakeroot\-ng creates a temporary file and maps it into memory as executable segment. Some systems have their /tmp folder mounted with the \fBnoexec\fP flag. On those system, the mmap will fail and fakeroot\-ng will not run. There are two environment variables that allow fakeroot\-ng to find a folder in which the shared memory files can be created. The first is \fBTMPDIR\fP. If it exists, fakeroot\-ng will use it to create the temporary files, rather than /tmp. The problem with using \fBTMPDIR\fP for creating temporary files is that fakeroot\-ng is not the only one to use it. For that reason, if the environment has a variable called \fBFAEKROOT_TMPDIR\fP, its value will override that of either \fBTMPDIR\fP or the default /tmp directory. On Linux, it is usually entirely safe to point \fBFAKEROOT_TMPDIR\fP to \fB/dev/shm\fP, which usually lives up to expectations regarding mount mode and writability. .SH SECURITY CONSIDERATIONS Fakeroot\-ng is a non-SUID executable, and does not modify any sensitive data. It, therefor, does not affect the overall security of the system. One may be tempted, however, to use fakeroot\-ng as a security tool, for running processes with reduced privileges or inside a chroot jail. In addition to all the warnings that usually apply to using chroot jails as a security tool (in a nutshell - don't), the following should be understood. .PP Unlike previous implementations, fakeroot\-ng uses a technology that leaves the traced process no choice regarding whether it will use fakeroot\-ng's "services" or not. Compiling a program statically, directly calling the kernel and manipulating ones own address space are all techniques that can be trivially used to bypass LD_PRELOAD based control over a process, and do not apply to fakeroot\-ng. It is, theoretically, possible to mold fakeroot\-ng in such a way as to have total control over the traced process. .PP While it is theoretically possible, it has not been done. Fakeroot\-ng does assume certain "nicely behaved" assumptions about the process being traced, and a process that break those assumptions may be able to, if not totally escape then at least circumvent some of the "fake" environment imposed on it by fakeroot\-ng. As such, you are strongly warned against using fakeroot\-ng as a security tool. Bug reports that claim that a process can deliberatly (as opposed to inadvertly) escape fakeroot\-ng's control will either be closed as "not a bug" or marked as low priority. .PP It is possible that this policy be rethought in the future. For the time being, however, you have been warned. .SH BUGS Plenty of those. See the "README" file for a list of known ones. .SH SEE ALSO .BR fakeroot "(1), " fakechroot "(1), " ptrace "(2), " ld.so "(8), " chroot (1) .SH AUTHOR Fakeroot\-ng was written by Shachar Shemesh. .PP This manual page was written by Shachar Shemesh .SH PROJECT HOMEPAGE AND SUPPORT http://fakeroot-ng.lingnu.com .PP Community support is available exclusively through the project's mailing list, at https://lists.sourceforge.net/lists/listinfo/fakerootng\-devel. .PP Commercial support is available through Shachar's company, Lingnu Open Source Consulting Ltd., at http://www.lingnu.com fakeroot-ng-0.18/config.h.in0000644000175000017500000001375512131751664014116 0ustar sunsun/* config.h.in. Generated from configure.ac by autoheader. */ /* How to tell the compiler that this is a printf style function */ #undef COMPHINT_PRINTF /* Where to create shared memory files if no environment overrides */ #undef DEFAULT_TMPDIR /* Define to 1 if your system has a working `chown' function. */ #undef HAVE_CHOWN /* Define to 1 if you have the declaration of `PR_SET_PTRACER', and to 0 if you don't. */ #undef HAVE_DECL_PR_SET_PTRACER /* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */ #undef HAVE_DOPRNT /* Define to 1 if you have the header file. */ #undef HAVE_FCNTL_H /* Define to 1 if you have the `fork' function. */ #undef HAVE_FORK /* Define to 1 if you have the `ftruncate' function. */ #undef HAVE_FTRUNCATE /* Define to 1 if you have the `getcwd' function. */ #undef HAVE_GETCWD /* Define to 1 if you have the `getpagesize' function. */ #undef HAVE_GETPAGESIZE /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #undef HAVE_LIMITS_H /* Define to 1 if `lstat' has the bug that it succeeds when given the zero-length file name argument. */ #undef HAVE_LSTAT_EMPTY_STRING_BUG /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the `memset' function. */ #undef HAVE_MEMSET /* Define to 1 if you have the `mkdir' function. */ #undef HAVE_MKDIR /* Define to 1 if you have a working `mmap' system call. */ #undef HAVE_MMAP /* Define to 1 if you have the `munmap' function. */ #undef HAVE_MUNMAP /* Supports the openat class of functions */ #undef HAVE_OPENAT /* Ptrace defines a single syscall for getting all registers */ #undef HAVE_PTRACE_GETREGS /* Ptrace defines a syscall for getting a single register */ #undef HAVE_PTRACE_PEEKUSER /* Define to 1 if you have the `realpath' function. */ #undef HAVE_REALPATH /* Define to 1 if you have the `select' function. */ #undef HAVE_SELECT /* Define to 1 if you have the `socket' function. */ #undef HAVE_SOCKET /* Define to 1 if stdbool.h conforms to C99. */ #undef HAVE_STDBOOL_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_STDLIB_H /* Define to 1 if you have the `strchr' function. */ #undef HAVE_STRCHR /* Define to 1 if you have the `strerror' function. */ #undef HAVE_STRERROR /* 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 `strtoul' function. */ #undef HAVE_STRTOUL /* Define to 1 if you have the header file. */ #undef HAVE_SYS_FILE_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_PRCTL_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_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 that is POSIX.1 compatible. */ #undef HAVE_SYS_WAIT_H /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if you have the `vfork' function. */ #undef HAVE_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_VFORK_H /* Define to 1 if you have the `vprintf' function. */ #undef HAVE_VPRINTF /* Define to 1 if `fork' works. */ #undef HAVE_WORKING_FORK /* Define to 1 if `vfork' works. */ #undef HAVE_WORKING_VFORK /* Define to 1 if the system has the type `_Bool'. */ #undef HAVE__BOOL /* Define to 1 if `lstat' dereferences a symlink specified with a trailing slash. */ #undef LSTAT_FOLLOWS_SLASHED_SYMLINK /* Name of package */ #undef PACKAGE /* 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 home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* GID for root */ #undef ROOT_GID /* UID for root */ #undef ROOT_UID /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* Enable extensions on AIX 3, Interix. */ #ifndef _ALL_SOURCE # undef _ALL_SOURCE #endif /* Enable GNU extensions on systems that have them. */ #ifndef _GNU_SOURCE # undef _GNU_SOURCE #endif /* Enable threading extensions on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # undef _POSIX_PTHREAD_SEMANTICS #endif /* Enable extensions on HP NonStop. */ #ifndef _TANDEM_SOURCE # undef _TANDEM_SOURCE #endif /* Enable general extensions on Solaris. */ #ifndef __EXTENSIONS__ # undef __EXTENSIONS__ #endif /* Version number of package */ #undef VERSION /* Enable openat functions */ #undef _ATFILE_SOURCE /* Define to 1 if on MINIX. */ #undef _MINIX /* Define to 2 if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define to 1 if you need to in order for `stat' and other things to work. */ #undef _POSIX_SOURCE /* Define to empty if `const' does not conform to ANSI C. */ #undef const /* Define to `int' if doesn't define. */ #undef gid_t /* Define to `int' if does not define. */ #undef mode_t /* Define to `int' if does not define. */ #undef pid_t /* Define to `unsigned int' if does not define. */ #undef size_t /* Define to `int' if does not define. */ #undef ssize_t /* Define to `int' if doesn't define. */ #undef uid_t /* Define as `fork' if `vfork' does not work. */ #undef vfork fakeroot-ng-0.18/chroot.cpp0000644000175000017500000002552212126275462014071 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include #include "syscalls.h" #include "parent.h" #include "chroot.h" // These are the Linux kernel parameters static const int GLOBAL_LINKS=40, // How many links are globally allowed in the dir part of the resolution LOCAL_LINKS=8, // How many links each directory level is allowed to have nested LAST_MILE_LINKS=32; // How many links are allowed in the file part of the link bool chroot_is_chrooted( const pid_state *state ) { return *state->root!="" && *state->root!="/"; } // XXX The memory efficiency of the implementation can use a DRASTIC improvement static std::string chroot_parse_path_recursion( const pid_state *state, char *path, const std::string &wd, struct stat *stat, int &global_link_count, int dir_link_count, bool resolve_links ) { std::string partial_path; // Body of function - find out the last path component position int last_slash=-1; for( int i=0; path[i]!='\0'; ++i ) if( path[i]=='/' ) last_slash=i; std::string file_part( path+last_slash+1 ); // Remove redundant slashes while( last_slash>0 && path[last_slash-1]=='/' ) last_slash--; std::string dir_part; if( last_slash>0 ) { // A slash appears in the file name, and it is not the first character path[last_slash]='\0'; // Chop off the file part dir_part=chroot_parse_path_recursion( state, path, wd, stat, global_link_count, LOCAL_LINKS, true ); // Translate the rest of the path if( (int)stat->st_ino==-1 ) { // Pass the error on - no further processing return dir_part+"/"+file_part; } } else if( last_slash==0 ) { // Need to process the leading slash dir_part=*state->root; } else { // A file part is all we have to begin with - see what the we are relative to dir_part=wd; } // At this point we have the leading directory in our (debugger) context, and the file part in debugee context if( file_part=="." || file_part=="" ) { // Same directory - do nothing more return dir_part; } if( file_part==".." ) { // We need to go one directory up. This is not as simple as it sounds // Are we currently at the root (either real or jail)? if( dir_part==*state->root || dir_part=="/" ) { // Going up is the same as staying at the same place return dir_part; } // Again - find the last slash in the string, and strip everything after it size_t last=dir_part.rfind('/'); if( last==std::string::npos ) { dlog("chroot_parse_path: dir part \"%s\" with file part \"..\" has no way to go one up\n", dir_part.c_str()); dlog(NULL); assert( last!=std::string::npos ); } // Eliminate repeats while( last>0 && dir_part[last-1]=='/' ) last--; if( last==0 ) // Leave one slash in place if that's all there is last++; return dir_part.substr(0, last); } // We now, finally, have an honest to god, non empty, non special, file part to handle std::string combined_path=dir_part+"/"+file_part; if( lstat( combined_path.c_str(), stat )==-1 ) { // We failed to stat the file. Just bounce the error to the caller stat->st_ino=-1; return combined_path; } // Is this a symbolic link? while( resolve_links && dir_link_count>0 && S_ISLNK(stat->st_mode) ) { if( (dir_link_count--)==0 || (global_link_count--)==0 ) { // We are out of patience for link processing errno=ELOOP; stat->st_ino=-1; return ""; } char buffer[PATH_MAX+1]; ssize_t link_len=readlink( combined_path.c_str(), buffer, sizeof(buffer) ); if( link_len==-1 ) { dlog("chroot_parse_path_recursion: lstat succeeded for %s, but readlink failed: %s\n", combined_path.c_str(), strerror(errno) ); return combined_path; } if( link_len==sizeof(buffer) ) { // Symbolic link's content is too long errno=ENAMETOOLONG; stat->st_ino=-1; return ""; } buffer[link_len]='\0'; if( strchr( buffer, '/' )==NULL ) { // The / character does not appear - just replace file_part with the new version file_part=buffer; combined_path=dir_part+"/"+file_part; if( lstat( combined_path.c_str(), stat )==-1 ) { // We failed to stat the file. Just bounce the error to the caller stat->st_ino=-1; return combined_path; } } else { // The symlink is a complex path - use ourselves recursively to figure out where it actually links to return chroot_parse_path_recursion( state, buffer, dir_part, stat, global_link_count, dir_link_count, false ); } } return combined_path; } // Actual implementation - some sanity checking, and then call the recursive version std::string chroot_parse_path( const pid_state *state, char *path, const std::string &wd, struct stat *stat, bool resolve_last_link ) { stat->st_ino=-2; // Mark this as a no-op. If we later do run a stat, it will be overridden if( path==NULL || path[0]=='\0' ) { stat->st_ino=-1; errno=ENOENT; return ""; } int total_links=GLOBAL_LINKS; if( log_level==0 ) return chroot_parse_path_recursion( state, path, wd, stat, total_links, LAST_MILE_LINKS, resolve_last_link ); else { dlog("chroot_parse_path: translating %s with work dir of %s\n", path, wd.c_str()); std::string ret=chroot_parse_path_recursion( state, path, wd, stat, total_links, LAST_MILE_LINKS, resolve_last_link ); dlog("chroot_parse_path: translated path is %s\n", ret.c_str() ); return ret; } } std::string chroot_translate_addr( pid_t pid, const pid_state *state, struct stat *stat, int dirfd, int_ptr addr, bool resolve_last_link ) { char filename[PATH_MAX], wd[PATH_MAX]; ptlib_get_string( pid, addr, filename, sizeof(filename) ); strcpy( wd, "/" ); // Get the process' working dir if( dirfd==CHROOT_PWD ) ptlib_get_cwd( pid, wd, sizeof(wd) ); else ptlib_get_fd( pid, dirfd, wd, sizeof(wd) ); return chroot_parse_path( state, filename, wd, stat, resolve_last_link ); } bool chroot_translate_param( pid_t pid, const pid_state *state, int param_num, bool resolve_last_link, bool abort_error, int_ptr offset ) { return chroot_translate_paramat( pid, state, CHROOT_PWD, param_num, resolve_last_link, abort_error, offset ); } // Same as chroot_translate_param, only for the *at family of functions bool chroot_translate_paramat( pid_t pid, const pid_state *state, int dirfd, int param_num, bool resolve_last_link, bool abort_error, int_ptr offset ) { // Short path if we are not chrooted if( !chroot_is_chrooted(state) ) return true; int_ptr path_addr=ptlib_get_argument( pid, param_num ); if( path_addr==(int_ptr)NULL ) { // The process asked to work directly on the file descriptor - do not touch the path return true; } struct stat stat; std::string newpath=chroot_translate_addr( pid, state, &stat, dirfd, path_addr, resolve_last_link ); if( stat.st_ino!=(ino_t)-1 || !abort_error ) { strcpy( state->mem->get_loc_c()+offset, newpath.c_str() ); ptlib_set_argument( pid, param_num, state->mem->get_shared()+offset ); } return stat.st_ino!=(ino_t)-1; } bool sys_chroot( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { // Save the path pointer and NOP the call state->context_state[0]=ptlib_get_argument( pid, 1 ); state->state=pid_state::REDIRECT2; ptlib_set_syscall( pid, PREF_NOP ); } else if( state->state==pid_state::REDIRECT2 ) { // We may already be chrooted - need to translate the path struct stat stat; ref_count newroot(new std::string( chroot_translate_addr( pid, state, &stat, CHROOT_PWD, state->context_state[0], true ))); if( (int)stat.st_ino!=-1 ) { // The call succeeded state->root=newroot; ptlib_set_retval( pid, 0 ); // Success returns 0 } else { // The call failed ptlib_set_error( pid, sc_num, errno ); } state->state=pid_state::NONE; } return true; } // This function handles the generic case where the function is one that does not need fake root // special handling, except we need to translate the first parameter in case we are chrooted bool sys_generic_chroot_support_param1( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_param( pid, state, 1, true ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } // Same as above, only when the last link is not resolved bool sys_generic_chroot_support_link_param1( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_param( pid, state, 1, false ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } bool sys_generic_chroot_support_param2( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_param( pid, state, 2, true ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } fakeroot-ng-0.18/exceptions.h0000644000175000017500000000145512126212571014410 0ustar sunsun#ifndef EXCEPTIONS_H #define EXCEPTIONS_H #include #include #include class errno_exception : public std::exception { int _errno; const char * _context; public: errno_exception( const char * context ) : _errno( errno ), _context( context ) {} const char * what() const throw() { return _context; } int get_error() const throw() { return _errno; } const char *get_error_message() const throw() { return strerror(_errno); } }; class detailed_exception : public std::exception { const char * _message; public: detailed_exception( const char * message ) : _message( message ) {} const char * what() const throw() { return _message; } }; #endif // EXCEPTIONS_H fakeroot-ng-0.18/README.porting0000644000175000017500000002702110756512760014426 0ustar sunsunThis document lists the steps required to port fakeroot-ng to a new platform. SHORT INSTRUCTIONS - Create a directory called arch/// - Create a file called arch///platform_specific.h. It needs to define all the constants defined by arch/linux/i386 as well as the ptlib_stat structure. - Implement all functions declared in arch/platform.h - Make sure that Makefile.in translates into a makefile that builds the library Simplicity at its best! LONG INSTRUCTIONS Welcome porter. Fakeroot-ng is a ptrace based syscall interceptor/emulator. As such, it has some characteristics usually only found inside a kernel (see the sys_wait4 impelementation). Most such characteristics are inside the main code, and are aimed to be done in a platform independent way. Some things are, unavoidably, done on a per-platform basis. In order to reduce the use of in code #ifdefs, every attempt was made to isolate the platform dependent functions into a library called "ptlib". It is built inside the arch// directory. You job, should you choose to accept it, is to implement ptlib for a new platform. INITIAL SUPPORT Probably the first step in implementing support for a new platform is to create a build environment for the platform. This is done by adding the arch/os/cpu directory to the source control. When "configure" is run, it detects the TARGET platform, and the rest of the build system looks there for the ptlib implementation. Sometimes, several platforms share the same ptlib implementation. For example, we don't care which 32 bit Intel/AMD CPU is running our code. Be it oldest 386 or newest Opetron, we intercept the syscalls the same way and use, basically, the same kernel. As such, autoconf platform detection is a done with too much granularity for our taste. To compensate for that, configure.ac has code to turn the i486, i586 etc. CPUs to "i386". If your platform also has several names that are, essentially, identical, feel free to copy this code. Please note that the above does not apply if you need to support two platforms at once (say, a 64 bit platform that is able to run 32 bit executables). Typically that requires syscall translation. That case is explained further down. Once the directory is created, you will need to create a file called "platform_support.h" inside it. This file is automatically included by the main ptlib include file, and any definition done here is visible throughout the project. Some definitions are mandatory, and those will be covered in the next section. PLATFORM_SPECIFIC.H This file should define constants used throughout the rest of the project. Its content range from defining kernel structures to specifying runtime behavior. Please note that while it is possible to test for the behavior using a test program, fakeroot-ng does not do so as part of the configure script. The reason is that those tests require a runtime environment, which means they cannot be performed on a cross-compiler environment. Instead, the tests directory contains a program called "calc_defaults". It attempts to give suggestions as to what should be the right values for platform_specific.h. The first part of the include file are the includes. You will need to add here whatever includes are necessary to expose the data types the program will need. The most obvious includes that need to go here are the includes that will define the syscall numbers with the SYS_ extension. For example, under Linux on i386, the "read" system call is number 3. On Linux on the X86_64 (aka amd64) it is number 0. Either way, SYS_read needs to resolve to the right number, and the includes in platform_specific.h need to make that happen. Under Linux, this is as simple as including . The next part is a set of preprocessor definitions that determine what capabilities ptlib supports. It does not matter whether the system supports those capabilities by default, or even if they are natively supported. All that matters is whether ptlib can give the impression that they are supported. These are the macros, and their meaning: PTLIB_SUPPORTS_FORK/VFORK/CLONE - ptlib is able to set up the system so that it automatically continues to trace both parent and child after a call to fork/ vfork/clone respectively. If that is not the case, some magic using trampuline code is required. PTLIB_PARENT_CAN_WAIT - if this value is 1, on this platform a parent that calls "wait" to collect a child that is also being debugged by another process will receive the exit status. Implicit to this macro is that if the parent does not call "wait" then the child will remain a zombie, even if the debugger did call wait for it. On some platforms, when a process debuggs another, the original parent siezes to function as one. Those platforms should set this value to zero. PTLIB_STATE_SIZE - how many PTLIB_LONGs are required to completely save the state of the process, so we can resume it to the same position. Fakeroot-ng will save that much memory for each process for those cases where it is necessary to freeze a process' state, do some processing on it, and then restore it to the original state. PTLIB_TRAP_AFTER_EXEC - on some platforms, if a process is being traced, the system sends it a SIGTRAP after a successful execve. This has the effect of notifying the debugger that the process performed an execve, even if it was not in PTRACE_SYSCALL mode. In addition to the binary defines, we also need to define several helpers: PID_F - the printf format specifier for printing pids DEV_F - the printf format specifier for printing dev_t INODE_F - the printf format specifier for printing inode_t (inodes) PREF_NOP - sometime we want to cancel a system call altogether. This is, typically, impossible. Instead, we translate the syscall into another syscall that has no effect and takes little time. getuid is usually a good choice. PREF_STAT/LSTAT,FSTAT,FSTATAT - the preferred syscall for performing stat/lstat and the rest of the stat functions. These functions should be able to cover the entire range of inodes. ptlib_stat - either a typedef or an explicit struct definition (usually the later) for the data format with which data is passed fromt the kernel when using the various PREF_STAT syscalls. Notice that, due to the fact that some of the members of the standard stat structure are actually preprocessor macros, the members have been renamed from their usual names. In particular, we drop the st_ prefix. At the very least the struct should define the following members: dev, ino (for the inode), mode, nlink, uid, gid, rdev and {a,m,c}time. ACTUAL PTLIB IMPLEMENTATION If you are merely adding support for a new Linux platform, have a look at the functions already defined in arch/linux/os.c. If you find that these implementations do the job, all you have to do is to place an implementation of the relelvant function that redirects to the function in os.c. The first thing you need to know about your platform is how syscalls are done, how parameters are passed to the kernel, how the results are returned, and how error conditions are being signalled and error codes passed. Personally, I found that the best way to get that information is to compile statically a tiny program that merely performs a system call, and then look at the resulting assembly. "mmap" is a good function to test, because it has the most arguments from all Linux (and possibly Posix) system calls. Then again, it has so many arguments that, for example, Linux/i386 treats it differently than it does other system calls. There really is no "one method" to find this out. Another good place to look is inside the glibc (or whatever runtime library your platform uses) source code, if you have it. Even if you don't, a disassembly can teach you a lot about the interface. Keep in mind that the differences can be major. For example, the Linux/i386 platform indicates an error by returning a negative value (which glibc then makes positive and places in errno). Linux/ppc, on the other hand, indicates an error by turning on a condition flag, and errno is returned as the positive return code. Every attempt was made to make ptlib flexible enough to support it all, but if you find the interface lacking, please feel free to bring it up on the mailing list. DEBUGGED PROCESS STATE The case may be that your platform requires knowing something about the debugged process' state before finding out information about it. For example, on Linux/x86_64 it is necessary to know whether the debugged process is running as a 64 or a 32 bit process. Fakeroot-ng is set up as to allow ptlib to find this information once, and then cache it so long as it is not possible to change. The key is the ptlib_continue function. As long as it has not been called, the process has not be resumed, and any state information collected about it is still valid. SEVERAL ARCHITECTURES IN ONE Some hardware platforms have several possible architectures rolled into one. It may be a 32/64 bit subsystem with different register allocations and system call numbers, it may be a compatibility ABI mechanism that allows running programs written for another OS, or it may be something crazier still. As long as ptlib can export a coherent view of what the state is, it should strive to do so. If a system call can pass parameters in four different methods then ptlib should handle all four, and still have ptlib_get_argument return the right value. Some cases, however, are more difficult to maintain. In particular, it may be that the different architectures assign different system call numbers to the same system calls. The following is just a suggestion on how to handle that case: Make up your mind what is the "main" interface to the kernel. Make sure that the info exported from ptlib is always in that main interface language. For 32/64 bit platforms, this will likely be the 64 bit interface. For the rest of this discussion we'll assume that 64 bit is the main interface, and 32 bit the auxillary one. Create a table that translates all syscalls in the 32 bit architecture to the syscalls in the 64 bit one. This is required for handling the ptlib_get_syscall function. One way to create this table is to copy the syscalls definition from the 32 bit header (/usr/include/asm-i386/unistd.h) to an array. Since they are ordered, the array index will be the 32 bit syscall. Since the actual definitions come from the 64 bit environment, the data will be the 64 bit counterpart. The easiest way to create the reverse table is in runtime inside ptlib_init. The problem is that not all 32 bit syscalls even have 64 bit counter parts. Linux/i386 has two "getuid" functions (one 16 bit, one 32). Linux/x86_64 has just one (64 bit). This gets worse for the "stat" function. Linux/x86_64 has three (oldstat, stat and stat64, not including fstatat that has different parameters). Linux/x86_64 has just one. The actual structure passed to all four is different. "stat" is a special case, described later. For the rest of the functions, if fakeroot-ng does not need to handle this syscall, you can just assign is the value -1. Fakeroot-ng will pick it up and not handle the syscall. If fakeroot-ng does need to handle this syscall, you can just assign it a fictional syscall number. To avoid collision, the X86_64 implementation uses negative numbers (starting with -2, of course). TODO: Describe the "stat" special handling. REFERENCES The following places are interesting places to look for hints on how to deal with certain cases: - configure.ac for linux/i386 - cases where several HW platforms require the same name (i386, i486, i586 etc.) - the implementation for linux/x86_64 - several different subsystems fakeroot-ng-0.18/log.cpp0000644000175000017500000000204212126212571013334 0ustar sunsun#include "config.h" #include "log.h" #include "arch/platform.h" #include #include static bool log_flush=false; int log_level=0; static FILE *debug_log; bool init_log( const char * file_name, bool flush ) { if( debug_log==NULL ) { debug_log=fopen(file_name, "at"); if( debug_log==NULL ) { perror("fakeroot-ng: Could not open debug log"); return false; } else { log_level=1; } log_flush=flush; } return true; } void close_log() { if( debug_log!=NULL ) fclose(debug_log); } void __dlog_( const char *format, ... ) { if( debug_log!=NULL ) { if( format!=NULL ) { va_list params; va_start(params, format); vfprintf(debug_log, format, params); va_end(params); } if( format==NULL || log_flush ) { fflush( debug_log ); } } } int get_log_fd() { if( debug_log!=NULL ) return fileno(debug_log); else return -1; } fakeroot-ng-0.18/tests/0000755000175000017500000000000012131751664013222 5ustar sunsunfakeroot-ng-0.18/tests/wait_test.cpp0000644000175000017500000000207712126275462015740 0ustar sunsun#include #include #include #include #include int main( int argc, char *argv[] ) { int numchildren=1; if( argc==2 ) { numchildren=strtoul( argv[1], NULL, 0 ); } for( int i=0; i #include #include #include #include #include #include #include #include using namespace std; int parent_wait_test() { int pfd[2]; if( pipe(pfd)!=0 ) { perror("parent_wait_test: pipe creation error"); exit(1); } pid_t child1, child2, parent=getpid(); child1=fork(); if( child1==-1 ) { perror("parent_wait_test: fork1 error"); exit(1); } if( child1==0 ) { /* We are the first child - sync on the pipe and then exit */ close( pfd[1] ); /* Close the writing end */ char buffer; if( read( pfd[0], &buffer, 1 )!=1 ) { perror("parent_wait_test: child1 sync read error"); exit(1); } exit(0); } child2=fork(); if( child2==-1 ) { perror("parent_wait_test: fork2 error"); kill( child1, SIGKILL ); exit(1); } if( child2==0 ) { close( pfd[0] ); /* We are the second child - detach ourselves */ pid_t grandchild=fork(); if( grandchild==-1 ) { perror("parent_wait_test: grandchild fork error"); exit(1); } if( grandchild==0 ) { /* We are the grand child */ if( ptrace( PTRACE_ATTACH, child1, 0, 0 )!=0 ) { perror("parent_wait_test: ptrace attach failed"); kill( child1, SIGKILL ); exit(1); } // Attched ok - free child1 to exit write( pfd[1], "a", 1 ); close( pfd[1] ); // Now wait for the child to exit int status; while( waitpid( child1, &status, 0 )==child1 && !WIFEXITED(status) ) { ptrace(PTRACE_CONT, child1, 0, 0); } // Sleep for a second (should be enough to make sure the parent waits successfully) and then kill the parent sleep(1); kill( parent, SIGKILL ); exit(0); } else { /* We are the second child */ exit(0); } } /* We are the parent */ int status; if( waitpid( child2, &status, 0 )<0 ) { perror("parent_wait_test: wait(child2) failed"); kill( child1, SIGKILL); exit(1); } if( !WIFEXITED(status) || WEXITSTATUS(status)!=0 ) { // Something failed with the child kill( child1, SIGKILL ); exit(1); } // Debugger child is ok (probably) - lets wait for the debuggee if( waitpid( child1, &status, 0 )==child1 ) { // Wait successful - make sure it really is if( WIFEXITED(status) && WEXITSTATUS(status)==0 ) { // Yes, everything is ok return 1; } else { // The wait was successfull, but the subprocess not - exit with failure exit(1); } } else { // Maybe the wait failed, but maybe the system just told us that this process is not our child if( errno==ECHILD ) { // It's just that we cannot wait on this particular child. Signal the parent so kill( parent, SIGKILL ); exit(1); } } return 0; } int main() { cerr<<"Sizes: char "<=0 && buffer[max1]==0; --max1) buffer[max1]=(void*)1; /* Transfer registers, again */ ptrace(PTRACE_GETREGS, child, buffer, buffer); /* Find out at how high the buffer was filled when initialized to a differnet value */ for( max2=4095; max2>max1 && buffer[max2]==(void *)1; --max2) ; /* Max2 is now how much data is being copied during a GETREGS call */ printf("#define PTLIB_STATE_SIZE (%d)\n", max2+1); /* Kill the waiting process */ ptrace(PTRACE_KILL, child, 0, 0); waitpid(child, &status, 0 ); } else { fprintf(stderr, "Error: child %d did not trace correctly\n", child); return 1; } } #endif /* PTRACE_GETREGS */ return 0; } fakeroot-ng-0.18/tests/pwd.c0000644000175000017500000000101410772212106014144 0ustar sunsun#include #include #include #include #include int main() { char buffer[PATH_MAX]; getcwd( buffer, sizeof(buffer) ); printf("Current directory is %s\n", buffer ); mkdir("dir", 0777); chroot( "dir"); getcwd( buffer, sizeof(buffer) ); printf("With chroot to dir, current directory is %s\n", buffer); chdir("dir"); getcwd( buffer, sizeof(buffer) ); printf("After chdir, current directory is %s\n", buffer); return 0; } fakeroot-ng-0.18/tests/Makefile.am0000644000175000017500000000045412076451407015261 0ustar sunsunnoinst_PROGRAMS=fbomb wait_test exercise calc_defaults pwd getsiginfo thread wait_test_SOURCES=wait_test.cpp fbomb_SOURCES=fbomb.cpp exercise_SOURCES=exercise.c calc_defaults_SOURCES=calc_defaults.cpp pwd_SOURCES=pwd.c getsiginfo_SOURCES=getsiginfo.c thread_SOURCES=thread.c thread_LDFLAGS=-pthread fakeroot-ng-0.18/tests/Makefile.in0000644000175000017500000003513412131751664015275 0ustar sunsun# Makefile.in generated by automake 1.11.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, # 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, # Inc. # This Makefile.in is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, # with or without modifications, as long as this notice is preserved. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY, to the extent permitted by law; without # even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. @SET_MAKE@ VPATH = @srcdir@ pkgdatadir = $(datadir)/@PACKAGE@ pkgincludedir = $(includedir)/@PACKAGE@ pkglibdir = $(libdir)/@PACKAGE@ pkglibexecdir = $(libexecdir)/@PACKAGE@ am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd install_sh_DATA = $(install_sh) -c -m 644 install_sh_PROGRAM = $(install_sh) -c install_sh_SCRIPT = $(install_sh) -c INSTALL_HEADER = $(INSTALL_DATA) transform = $(program_transform_name) NORMAL_INSTALL = : PRE_INSTALL = : POST_INSTALL = : NORMAL_UNINSTALL = : PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ target_triplet = @target@ noinst_PROGRAMS = fbomb$(EXEEXT) wait_test$(EXEEXT) exercise$(EXEEXT) \ calc_defaults$(EXEEXT) pwd$(EXEEXT) getsiginfo$(EXEEXT) \ thread$(EXEEXT) subdir = tests DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = PROGRAMS = $(noinst_PROGRAMS) am_calc_defaults_OBJECTS = calc_defaults.$(OBJEXT) calc_defaults_OBJECTS = $(am_calc_defaults_OBJECTS) calc_defaults_LDADD = $(LDADD) am_exercise_OBJECTS = exercise.$(OBJEXT) exercise_OBJECTS = $(am_exercise_OBJECTS) exercise_LDADD = $(LDADD) am_fbomb_OBJECTS = fbomb.$(OBJEXT) fbomb_OBJECTS = $(am_fbomb_OBJECTS) fbomb_LDADD = $(LDADD) am_getsiginfo_OBJECTS = getsiginfo.$(OBJEXT) getsiginfo_OBJECTS = $(am_getsiginfo_OBJECTS) getsiginfo_LDADD = $(LDADD) am_pwd_OBJECTS = pwd.$(OBJEXT) pwd_OBJECTS = $(am_pwd_OBJECTS) pwd_LDADD = $(LDADD) am_thread_OBJECTS = thread.$(OBJEXT) thread_OBJECTS = $(am_thread_OBJECTS) thread_LDADD = $(LDADD) thread_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(thread_LDFLAGS) \ $(LDFLAGS) -o $@ am_wait_test_OBJECTS = wait_test.$(OBJEXT) wait_test_OBJECTS = $(am_wait_test_OBJECTS) wait_test_LDADD = $(LDADD) DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) depcomp = $(SHELL) $(top_srcdir)/depcomp am__depfiles_maybe = depfiles am__mv = mv -f COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) CCLD = $(CC) LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) CXXLD = $(CXX) CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \ -o $@ SOURCES = $(calc_defaults_SOURCES) $(exercise_SOURCES) \ $(fbomb_SOURCES) $(getsiginfo_SOURCES) $(pwd_SOURCES) \ $(thread_SOURCES) $(wait_test_SOURCES) ETAGS = etags CTAGS = ctags ACLOCAL = @ACLOCAL@ AMTAR = @AMTAR@ AUTOCONF = @AUTOCONF@ AUTOHEADER = @AUTOHEADER@ AUTOMAKE = @AUTOMAKE@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ CFLAGS = @CFLAGS@ CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ CXXDEPMODE = @CXXDEPMODE@ CXXFLAGS = @CXXFLAGS@ CYGPATH_W = @CYGPATH_W@ DEFS = @DEFS@ DEPDIR = @DEPDIR@ ECHO_C = @ECHO_C@ ECHO_N = @ECHO_N@ ECHO_T = @ECHO_T@ EGREP = @EGREP@ EXEEXT = @EXEEXT@ GREP = @GREP@ INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ INSTALL_PROGRAM = @INSTALL_PROGRAM@ INSTALL_SCRIPT = @INSTALL_SCRIPT@ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ LDFLAGS = @LDFLAGS@ LIBOBJS = @LIBOBJS@ LIBS = @LIBS@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ MAKEINFO = @MAKEINFO@ MKDIR_P = @MKDIR_P@ OBJEXT = @OBJEXT@ PACKAGE = @PACKAGE@ PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ VERSION = @VERSION@ abs_builddir = @abs_builddir@ abs_srcdir = @abs_srcdir@ abs_top_builddir = @abs_top_builddir@ abs_top_srcdir = @abs_top_srcdir@ ac_ct_CC = @ac_ct_CC@ ac_ct_CXX = @ac_ct_CXX@ am__include = @am__include@ am__leading_dot = @am__leading_dot@ am__quote = @am__quote@ am__tar = @am__tar@ am__untar = @am__untar@ bindir = @bindir@ build = @build@ build_alias = @build_alias@ build_cpu = @build_cpu@ build_os = @build_os@ build_vendor = @build_vendor@ builddir = @builddir@ datadir = @datadir@ datarootdir = @datarootdir@ docdir = @docdir@ dvidir = @dvidir@ exec_prefix = @exec_prefix@ host = @host@ host_alias = @host_alias@ host_cpu = @host_cpu@ host_os = @host_os@ host_vendor = @host_vendor@ htmldir = @htmldir@ includedir = @includedir@ infodir = @infodir@ install_sh = @install_sh@ libdir = @libdir@ libexecdir = @libexecdir@ localedir = @localedir@ localstatedir = @localstatedir@ mandir = @mandir@ mkdir_p = @mkdir_p@ oldincludedir = @oldincludedir@ pdfdir = @pdfdir@ prefix = @prefix@ program_transform_name = @program_transform_name@ psdir = @psdir@ sbindir = @sbindir@ sharedstatedir = @sharedstatedir@ srcdir = @srcdir@ sysconfdir = @sysconfdir@ target = @target@ target_alias = @target_alias@ target_cpu = @target_cpu@ target_os = @target_os@ target_vendor = @target_vendor@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ wait_test_SOURCES = wait_test.cpp fbomb_SOURCES = fbomb.cpp exercise_SOURCES = exercise.c calc_defaults_SOURCES = calc_defaults.cpp pwd_SOURCES = pwd.c getsiginfo_SOURCES = getsiginfo.c thread_SOURCES = thread.c thread_LDFLAGS = -pthread all: all-am .SUFFIXES: .SUFFIXES: .c .cpp .o .obj $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ *$$dep*) \ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ && { if test -f $@; then exit 0; else break; fi; }; \ exit 1;; \ esac; \ done; \ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --gnu tests/Makefile .PRECIOUS: Makefile Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status @case '$?' in \ *config.status*) \ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(top_srcdir)/configure: $(am__configure_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(ACLOCAL_M4): $(am__aclocal_m4_deps) cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): clean-noinstPROGRAMS: -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) calc_defaults$(EXEEXT): $(calc_defaults_OBJECTS) $(calc_defaults_DEPENDENCIES) @rm -f calc_defaults$(EXEEXT) $(CXXLINK) $(calc_defaults_OBJECTS) $(calc_defaults_LDADD) $(LIBS) exercise$(EXEEXT): $(exercise_OBJECTS) $(exercise_DEPENDENCIES) @rm -f exercise$(EXEEXT) $(LINK) $(exercise_OBJECTS) $(exercise_LDADD) $(LIBS) fbomb$(EXEEXT): $(fbomb_OBJECTS) $(fbomb_DEPENDENCIES) @rm -f fbomb$(EXEEXT) $(CXXLINK) $(fbomb_OBJECTS) $(fbomb_LDADD) $(LIBS) getsiginfo$(EXEEXT): $(getsiginfo_OBJECTS) $(getsiginfo_DEPENDENCIES) @rm -f getsiginfo$(EXEEXT) $(LINK) $(getsiginfo_OBJECTS) $(getsiginfo_LDADD) $(LIBS) pwd$(EXEEXT): $(pwd_OBJECTS) $(pwd_DEPENDENCIES) @rm -f pwd$(EXEEXT) $(LINK) $(pwd_OBJECTS) $(pwd_LDADD) $(LIBS) thread$(EXEEXT): $(thread_OBJECTS) $(thread_DEPENDENCIES) @rm -f thread$(EXEEXT) $(thread_LINK) $(thread_OBJECTS) $(thread_LDADD) $(LIBS) wait_test$(EXEEXT): $(wait_test_OBJECTS) $(wait_test_DEPENDENCIES) @rm -f wait_test$(EXEEXT) $(CXXLINK) $(wait_test_OBJECTS) $(wait_test_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/calc_defaults.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exercise.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fbomb.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getsiginfo.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pwd.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/thread.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/wait_test.Po@am__quote@ .c.o: @am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(COMPILE) -c $< .c.obj: @am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'` .cpp.o: @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< .cpp.obj: @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ mkid -fID $$unique tags: TAGS TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) set x; \ here=`pwd`; \ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ shift; \ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ test -n "$$unique" || unique=$$empty_fix; \ if test $$# -gt 0; then \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ "$$@" $$unique; \ else \ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ $$unique; \ fi; \ fi ctags: CTAGS CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ $(TAGS_FILES) $(LISP) list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ unique=`for i in $$list; do \ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ done | \ $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ END { if (nonempty) { for (i in files) print i; }; }'`; \ test -z "$(CTAGS_ARGS)$$unique" \ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ $$unique GTAGS: here=`$(am__cd) $(top_builddir) && pwd` \ && $(am__cd) $(top_srcdir) \ && gtags -i $(GTAGS_ARGS) "$$here" distclean-tags: -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags check-am: all-am check: check-am all-am: Makefile $(PROGRAMS) installdirs: install: install-am install-exec: install-exec-am install-data: install-data-am uninstall: uninstall-am install-am: all-am @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am installcheck: installcheck-am install-strip: $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ `test -z '$(STRIP)' || \ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install mostlyclean-generic: clean-generic: distclean-generic: -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) maintainer-clean-generic: @echo "This command is intended for maintainers to use" @echo "it deletes files that may require special tools to rebuild." clean: clean-am clean-am: clean-generic clean-noinstPROGRAMS mostlyclean-am distclean: distclean-am -rm -rf ./$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-tags dvi: dvi-am dvi-am: html: html-am html-am: info: info-am info-am: install-data-am: install-dvi: install-dvi-am install-dvi-am: install-exec-am: install-html: install-html-am install-html-am: install-info: install-info-am install-info-am: install-man: install-pdf: install-pdf-am install-pdf-am: install-ps: install-ps-am install-ps-am: installcheck-am: maintainer-clean: maintainer-clean-am -rm -rf ./$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic mostlyclean: mostlyclean-am mostlyclean-am: mostlyclean-compile mostlyclean-generic pdf: pdf-am pdf-am: ps: ps-am ps-am: uninstall-am: .MAKE: install-am install-strip .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ clean-noinstPROGRAMS ctags distclean distclean-compile \ distclean-generic distclean-tags dvi dvi-am html html-am info \ info-am install install-am install-data install-data-am \ install-dvi install-dvi-am install-exec install-exec-am \ install-html install-html-am install-info install-info-am \ install-man install-pdf install-pdf-am install-ps \ install-ps-am install-strip installcheck installcheck-am \ installdirs maintainer-clean maintainer-clean-generic \ mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \ ps ps-am tags uninstall uninstall-am # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: fakeroot-ng-0.18/tests/getsiginfo.c0000644000175000017500000000746211226303625015527 0ustar sunsun/* Copyright (C) 2009 by Shachar Shemesh 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include #include #include #include #include const char *translate_signal( int sig ) { #define DEFSIG(s) case s: return #s switch( sig ) { DEFSIG(SIGHUP); DEFSIG(SIGINT); DEFSIG(SIGQUIT); DEFSIG(SIGILL); DEFSIG(SIGABRT); DEFSIG(SIGFPE); DEFSIG(SIGKILL); DEFSIG(SIGSEGV); DEFSIG(SIGPIPE); DEFSIG(SIGALRM); DEFSIG(SIGTERM); DEFSIG(SIGUSR1); DEFSIG(SIGUSR2); DEFSIG(SIGCHLD); DEFSIG(SIGCONT); DEFSIG(SIGSTOP); DEFSIG(SIGTSTP); DEFSIG(SIGTTIN); DEFSIG(SIGTTOU); DEFSIG(SIGBUS); DEFSIG(SIGPOLL); DEFSIG(SIGPROF); DEFSIG(SIGSYS); DEFSIG(SIGTRAP); DEFSIG(SIGURG); DEFSIG(SIGVTALRM); DEFSIG(SIGXCPU); DEFSIG(SIGXFSZ); default: { static char buffer[50]; sprintf( buffer, "signal %d", sig ); return buffer; } } } // Returns 0 if process terminated // Signal number if stopped by that signal int print_wait_res( pid_t pid, int status ) { if( WIFEXITED(status) ) { printf("Process %d exit with exit code %d\n", pid, WEXITSTATUS(status) ); return 0; } if( WIFSIGNALED(status) ) { printf("Process %d exit with %s%s\n", pid, translate_signal(WTERMSIG(status)), WCOREDUMP(status) ? "" : "(core dumped)" ); return 0; } int signal=-1; if( WIFSTOPPED(status) ) { signal=WSTOPSIG(status); printf("Process %d stopped with %s\n", pid, translate_signal(signal) ); } return signal; } int process_parent( pid_t child ) { int sig; do { int status; pid_t pid; pid=wait(&status); sig=print_wait_res( pid, status ); if( sig==SIGTRAP ) { siginfo_t siginfo; long res=ptrace(PTRACE_GETSIGINFO, pid, 0, &siginfo); if( res<0 ) { perror("ptrace(GETSIGINFO failed)"); } else { printf("siginfo.si_code=%d\n", siginfo.si_code ); } ptrace(PTRACE_SYSCALL, pid, 0, 0); } else { int sig2=sig; if( sig2==SIGSTOP ) sig2=0; ptrace(PTRACE_SINGLESTEP, pid, 0, sig2); } } while( sig>0 ); return 0; } int process_child( char *us ) { if( ptrace( PTRACE_TRACEME, 0, 0, 0 )<0 ) { perror("ptrace(TRACEME) failed"); return 1; } kill(getpid(), SIGSTOP ); kill(getpid(), SIGTRAP ); char *argv[]={ us, "arg", NULL }; execvp( argv[0], argv ); return 2; } // Called when we exec ourselves int second_child_run() { return 3; } int main(int argc, char *argv[]) { pid_t child=fork(); if( argc>1 ) { return second_child_run(); } if( child<0 ) { perror("fork failed"); return 1; } if( child==0 ) { return process_child(argv[0]); } return process_parent( child ); } fakeroot-ng-0.18/tests/exercise.c0000644000175000017500000000410012130614054015156 0ustar sunsun/* This is a tool for exercising the various system calls we would potentially like to emulate with fakeroot-ng. * By definition, this tool should produce identical results when running under fakeroot-ng and when running as * root. */ #include "../config.h" #include #include #include #include #include #include #include int main( int argc, char *argv[] ) { uid_t uid=getuid(), euid=geteuid(); gid_t gid=getgid(), egid=getegid(); int dirfd; umask(0022); printf("uid %d euid %d gid %d egid %d\n", uid, euid, gid, egid ); if( mkdir("testdir", 0777)==0 ) { printf("mkdir succeeded\n"); } else { perror("mkdir failed"); exit(1); } chdir("testdir"); if( mknod( "file1", 0666 | S_IFREG, 0 )==0 ) { printf("file1 created using mknod\n"); } else { perror("file1 not created"); } #if HAVE_OPENAT if( fchownat( AT_FDCWD, "file1", 0, 12, 0 )==0 ) { printf("file1 fchownat to 0,12\n"); } else { perror("fchownat(file1, 0, 12) failed"); } dirfd = open(".", O_RDONLY|O_DIRECTORY); if (dirfd == -1) { perror("open ."); } chdir(".."); if( symlinkat( "file1", dirfd, "file2" )>=0 ) { printf("symlinkat file2->file1\n"); } else { perror("symlinkat file2->file1 failed"); } if( syscall( SYS_fchmodat, dirfd, "file2", 0000, AT_SYMLINK_NOFOLLOW )==0 ) { printf("file1 fchmodat 0000 through a symlink with flag to not follow symlinks\n"); } else { perror("file1 fchmodat failed"); } chdir("testdir"); struct stat stat; if( fstatat(dirfd, "file1", &stat, AT_SYMLINK_NOFOLLOW)>=0 ) { if( stat.st_mode==(S_IFREG|0000) ) { printf("fstatat of file1 returned correct permissions (no permissions)\n"); } else { printf("fstatat of file1 returned incorrect permissions (%04o)\n", stat.st_mode); } } else { perror("fstatat of file1 failed"); } #endif return 0; } fakeroot-ng-0.18/tests/fbomb.cpp0000644000175000017500000000263110731001465015004 0ustar sunsun#include "../config.h" #include #include #include #include #include #include #include int main( int argc, char * argv[] ) { // Create a "fork bomb", but with finite scope. // argv[1] should be the depth // argv[2]='r' means that we should recurse (creating 2^argv[1] processes, instead of just argv[1]) if( argc<2 ) return 1; int depth=0; int target=atoi(argv[1]); bool recurse=argc>=3 && argv[2][0]=='r'; int num_children=0; int serial=1; int origserial=1; bool stop=false; while( !stop && depth #include #include #include void *thread_sub( void *param ) { printf("child uid=%d\n", getuid() ); return 0; } int main(int argc, char *argv[]) { pthread_t thread; int err=pthread_create( &thread, NULL, thread_sub, 0 ); if( err==0 ) { printf("Parent uid=%d\n", getuid() ); } else { printf("Thread creationg error: %d\n", err ); return 1; } pthread_join( thread, NULL ); printf("Parent: child thread exit\n"); return 0; } fakeroot-ng-0.18/daemon.h0000644000175000017500000000610412130340173013461 0ustar sunsun#ifndef DAEMON_H #define DAEMON_H #include "exceptions.h" #include "unique_fd.h" #include #include #include class daemonProcess; template class ipcMessage; // Connect to the daemon, launching it if necessary, and return the connection fd class daemonCtrl { daemonCtrl( const daemonCtrl & )=delete; daemonCtrl & operator=( const daemonCtrl & )=delete; friend class daemonProcess; enum commands { CMD_RESERVE, CMD_ATTACH }; struct request { enum commands command; }; struct response { enum commands command; int result; }; public: class terminal_error : public detailed_exception { public: terminal_error( const char * msg ) : detailed_exception(msg) { } }; class remote_hangup_exception : public terminal_error { public: remote_hangup_exception() : terminal_error( "Remote hung up" ) {} }; class short_msg_exception : public terminal_error { public: short_msg_exception() : terminal_error( "Remote sent short message" ) {} }; private: int daemon_socket; pid_t daemon_pid; public: daemonCtrl(const char *state_file_path, bool nodetach); ~daemonCtrl(); void cmd_attach(); private: void connect( const char * state_file_path ); // Standard commands are commands with no reply other than "ACK" void send_std_cmd( commands command, ipcMessage &response ) const; static void set_client_sock_options( int fd ); void cmd_reserve(); }; class daemonProcess { daemonProcess( const daemonProcess & )=delete; daemonProcess & operator=( const daemonProcess & )=delete; std::list session_fds; fd_set file_set; int max_fd; std::string state_path; unique_fd master_socket; unique_fd state_fd; static bool daemonize( bool nodetach, int skip_fd1=-1, int skip_fd2=-1 ); explicit daemonProcess( int session_fd ); // Constructor for non-persistent daemon // Constructor for persistent daemon daemonProcess( const std::string &path, unique_fd &state_file, unique_fd &master_fd ); public: ~daemonProcess(); // Create an anonymous daemon process, returning the connection file descriptor static int create( bool nodetach ); static void create( const char *state_file_path, bool nodetach ); bool handle_request( const sigset_t *sigmask, bool existing_children ); static void set_client_sock_options( int fd ); private: void start(); void register_session( unique_fd &fd ); void unregister_Session( int fd ); void handle_new_connection(); void recalc_select_mask(); void close_session( decltype(session_fds)::iterator & element ); void handle_connection_request( decltype(session_fds)::iterator & element ); void handle_cmd_reserve( decltype(session_fds)::iterator &element, const ipcMessage &message ); void handle_cmd_attach( decltype(session_fds)::iterator &element, const ipcMessage &message ); }; #endif // DAEMON_H fakeroot-ng-0.18/parent.h0000644000175000017500000002002612126212571013513 0ustar sunsun#ifndef PARENT_H #define PARENT_H #include #include #include #include #include #include #include #include #include "arch/platform.h" #include "platform_specific.h" #include "refcount.h" extern size_t static_mem_size, shared_mem_size; bool attach_debugger( pid_t child ); class daemonProcess; int process_children( daemonProcess *daemon ); int process_sigchld( pid_t pid, enum PTLIB_WAIT_RET wait_state, int status, long ret ); // Called whenever a new process is created void handle_new_process( pid_t parent_id, pid_t child_id ); #define NUM_SAVED_STATES 5 struct pid_state { /* The list of states a process can be in. As far as the syscall handler is concerned, each state has a "before" and "after" semantics. Before - between the point the process has sent us a SIGTRAP and the handler being called After - between the handler's return and the process receiving a continue command Handlers should check for the before state and should set the after state Terminology: Inbound - this is the SIGTRAP sent to us right before the kernel processes the syscall Outbound - this is the SIGTRAP sent to us right after the kernel processed the syscall */ enum states { INIT, // Internal use - never set from a handler and will never be seen from a handler NONE, // Base state. Before - the process is inbound on a new syscall. // After - process is outbound from the last syscall in this sequence. RETURN, // After - process is inbound to an unmodified syscall. Before - process is outbound from an unmodified syscall. // The "unmodified" part is asserted by the main loop! Violating this constraint will crash the process in debug mode REDIRECT1, // After - Set in *Outbound* mode to indicate we initiated a new call with ptlib_generate_syscall // Before - handled internally by process_sigchld - handler will never be called with this state REDIRECT2, // Before - outbound on a modified syscall. May or may not be a result of ptlib_generate_syscall // After - Set when you want to change the original inbound syscall to something else. // Do not use RETURN under those circumstances, as it will violate the assertion. REDIRECT3, // This mode rarely makes sense. // After - handler generated a syscall, but would like to be notified when that syscall reaches inbound // Before - inbound on generated syscall ALLOCATE, ALLOC_RETURN, // The above two are used internally. The handler should never set them and will never see them set. WAITING, // After - the handler semantics needs to hold the process until some asynchronous operation is done. // This state is somewhat special, as it is not tied to an outbound/inbound state. // A handler setting this state should return false, to prevent process_sigchld from allowing the // process to continue running. // Before - the handler is called from "notify_parent", not "process_sigchld". Inbound/outbound depends on // // NOTICE: Release of a waiting process should not be done into the NONE state, as that would mean that if a recursive // debugger is connected to the process, it will not see the syscall return! ZOMBIE, // As with real processes - the process has terminated, but has not yet been waited on. } state; int orig_sc; // Original system call class process_memory { int_ptr memory; // Where and how much mem do we have inside the process's address space int_ptr shared_memory; // Process address of shared memory void *shared_mem_local; // local pointers to the shared memory size_t shared_overhead; // Size of the overhead the shared memory has size_t shared_size; // Total size of mapping // Disable the implicit constructors process_memory( const process_memory &rhs ); process_memory &operator=( const process_memory &rhs ); public: process_memory() : memory(0), shared_memory(0), shared_mem_local(MAP_FAILED), shared_overhead(0), shared_size(0) { } ~process_memory(); void set_local_addr(void *addr, size_t size, size_t overhead) { assert(shared_mem_local==MAP_FAILED); if( addr!=MAP_FAILED && addr!=NULL ) { shared_mem_local=(void *)(((int_ptr)addr)+overhead); shared_overhead=overhead; shared_size=size; } } void set_remote_static(int_ptr addr) { assert(memory==0); memory=addr; } void set_remote_shared(int_ptr addr) { shared_memory=addr; } // Accessors void *get_loc() const { return shared_mem_local!=MAP_FAILED ? shared_mem_local : NULL; } char *get_loc_c() const { return (char *)get_loc(); } int_ptr get_mem() const { return memory; } int_ptr get_shared() const { return shared_memory; } }; ref_count mem; int_ptr context_state[NUM_SAVED_STATES]; void *saved_state[PTLIB_STATE_SIZE]; // "wait" simulation and recursive debuggers support pid_t debugger, parent; // Which process thinks it's ptracing/parenting this one int num_children, num_debugees; // How many child/debugged processes we have int trace_mode; // Which ptrace mode was used to run the process pid_t session_id; ref_count root; // The credentials (including the Linux specific file system UID) uid_t uid, euid, suid, fsuid; gid_t gid, egid, sgid, fsgid; std::set groups; // Values for trace_mode #define TRACE_DETACHED 0x0 #define TRACE_CONT 0x1 #define TRACE_SYSCALL 0x2 #define TRACE_SINGLSTEP 0x3 #define TRACE_MASK1 0x7 #define TRACE_STOPPED1 0x10 #define TRACE_STOPPED2 0x20 #define TRACE_MASK2 0x70 #define DEF_VAR(type, name) private: type _##name; \ public: type &name() { return _##name; } const type &name() const { return _##name; } struct wait_state { DEF_VAR( pid_t, pid) DEF_VAR( int, status) DEF_VAR( struct rusage, usage) DEF_VAR( bool, debugonly) // Whether a parent that is not a debugger would have got this message public: wait_state() : _pid(0), _status(0), _debugonly(true) { } wait_state( pid_t pid, int status, const struct rusage *usage, bool debugonly ) : _pid(pid), _status(status), _usage(*usage), _debugonly(debugonly) { } }; #undef DEF_VAR std::list waiting_signals; pid_state() : state(INIT), mem(ref_count(new process_memory)), debugger(0), parent(0), num_children(0), num_debugees(0), trace_mode(TRACE_DETACHED), session_id(0), root(), uid(ROOT_UID), euid(ROOT_UID), suid(ROOT_UID), fsuid(ROOT_UID), gid(ROOT_GID), egid(ROOT_GID), sgid(ROOT_GID), fsgid(ROOT_GID) { groups.insert(ROOT_GID); } }; // Look up a state by pid. Return NULL if the state does not exist pid_state *lookup_state( pid_t pid ); // Delete a process. Must be called with state as ZOMBIE. // Does reference counting, and will only perform actual delete when no more users. void delete_state( pid_t pid ); // Dump all of the registered processes, including parent, state and zombie use count void dump_states(); typedef bool (*sys_callback)( int sc_num, pid_t pid, pid_state *state ); struct syscall_hook { sys_callback func; const char *name; syscall_hook() : func(NULL), name(NULL) { } syscall_hook( sys_callback _func, const char *_name ) : func(_func), name(_name) { } }; bool allocate_process_mem( pid_t pid, pid_state *state, int sc_num ); void dump_registers( pid_t pid ); #define PROC_MEM_LOCK() #endif /* PARENT_H */ fakeroot-ng-0.18/config.guess0000755000175000017500000012763712131751664014420 0ustar sunsun#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2009-12-30' # 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., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner. Please send patches (context # diff format) to and include a 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. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD 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, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # 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 "$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 ; set_cc_for_build= ;' # 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 ;; sh5el) machine=sh5le-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 -q __ELF__ 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 ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; 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 ;; 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 ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; 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 ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; 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 ;; 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 ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; 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 ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # 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 ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; 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 && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; 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 ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????: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 ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; 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 ;; *: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 if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi 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 ;; *:AIX:*:[456]) 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 ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 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 eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 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 && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; 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 ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; 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 ;; 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 ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) case ${UNAME_MACHINE} in pc98) echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; 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 ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *: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 ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; 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 -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else echo ${UNAME_MACHINE}-unknown-linux-gnueabi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo cris-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) echo frv-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #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; } ;; or32:Linux:*:*) echo or32-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; 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 ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo x86_64-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; 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 ;; 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 ;; 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 ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; 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 ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. 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 ;; 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 ;; 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 i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; 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 ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 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 | S7501*:*: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; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' 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; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *: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 ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; 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 ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *: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 ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *: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 ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; 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\n"); 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 && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # 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 ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; 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: fakeroot-ng-0.18/file_lie.h0000644000175000017500000000212111022035130013752 0ustar sunsun#ifndef FILE_LIE_H #define FILE_LIE_H #include // Define functions for mapping the real files on disk to what they should be as far as the fake environment is concerned #include "arch/platform.h" struct stat_override { dev_t dev; ptlib_inode_t inode; mode_t mode; uid_t uid; gid_t gid; dev_t dev_id; bool transient; stat_override() : transient(false) { } }; struct override_key { dev_t dev; ptlib_inode_t inode; override_key() : dev(0), inode(0) { } override_key( dev_t _dev, ino_t _inode ) : dev(_dev), inode(_inode) { } bool operator==( const override_key &rhs ) const { return dev==rhs.dev && inode==rhs.inode; } }; // Returns the information inside the database about a file with the given dev and inode // returns "false" if no such file exists bool get_map( dev_t dev, ptlib_inode_t inode, struct stat_override *stat ); void set_map( const struct stat_override *stat ); void remove_map( dev_t dev, ptlib_inode_t inode ); void load_map( FILE *file ); void save_map( FILE *file ); #endif // FILE_LIE_H fakeroot-ng-0.18/syscalls.h0000644000175000017500000000424711221724615014070 0ustar sunsun#ifndef SYSCALLS_H #define SYSCALLS_H #include "parent.h" #define DECLARE_SYSFUNC(name) bool sys_##name( int sc_num, pid_t pid, pid_state *state ) // UID reporting and setting DECLARE_SYSFUNC(geteuid); DECLARE_SYSFUNC(getuid); DECLARE_SYSFUNC(getegid); DECLARE_SYSFUNC(getgid); DECLARE_SYSFUNC(seteuid); DECLARE_SYSFUNC(setuid); DECLARE_SYSFUNC(setegid); DECLARE_SYSFUNC(setgid); DECLARE_SYSFUNC(setreuid); DECLARE_SYSFUNC(setregid); DECLARE_SYSFUNC(getgroups); DECLARE_SYSFUNC(setgroups); // UID Non-POSIX DECLARE_SYSFUNC(getresuid); DECLARE_SYSFUNC(getresgid); DECLARE_SYSFUNC(setresuid); DECLARE_SYSFUNC(setresgid); DECLARE_SYSFUNC(getfsuid); DECLARE_SYSFUNC(getfsgid); DECLARE_SYSFUNC(setfsuid); DECLARE_SYSFUNC(setfsgid); // Process management DECLARE_SYSFUNC(fork); DECLARE_SYSFUNC(vfork); DECLARE_SYSFUNC(waitpid); DECLARE_SYSFUNC(vfork); //DECLARE_SYSFUNC(execve) bool sys_execve( int sc_num, pid_t pid, pid_state *state, bool &post_trap ); DECLARE_SYSFUNC(setsid); DECLARE_SYSFUNC(ptrace); DECLARE_SYSFUNC(kill); // Process Non-POSIX DECLARE_SYSFUNC(wait4); DECLARE_SYSFUNC(clone); DECLARE_SYSFUNC(sigreturn); // File handling DECLARE_SYSFUNC(stat); #ifdef SYS_fstatat64 DECLARE_SYSFUNC(fstatat64); #endif DECLARE_SYSFUNC(chmod); DECLARE_SYSFUNC(fchmod); DECLARE_SYSFUNC(chown); DECLARE_SYSFUNC(fchown); DECLARE_SYSFUNC(lchown); DECLARE_SYSFUNC(mknod); DECLARE_SYSFUNC(open); DECLARE_SYSFUNC(mkdir); DECLARE_SYSFUNC(symlink); DECLARE_SYSFUNC(link); DECLARE_SYSFUNC(unlink); DECLARE_SYSFUNC(rename); DECLARE_SYSFUNC(rmdir); DECLARE_SYSFUNC(chroot); DECLARE_SYSFUNC(getcwd); DECLARE_SYSFUNC(munmap); // File Non-POSIX DECLARE_SYSFUNC(fchmodat); DECLARE_SYSFUNC(fchownat); DECLARE_SYSFUNC(mknodat); DECLARE_SYSFUNC(openat); DECLARE_SYSFUNC(mkdirat); DECLARE_SYSFUNC(symlinkat); DECLARE_SYSFUNC(linkat); DECLARE_SYSFUNC(unlinkat); DECLARE_SYSFUNC(renameat); DECLARE_SYSFUNC(generic_chroot_support_param1); DECLARE_SYSFUNC(generic_chroot_support_link_param1); DECLARE_SYSFUNC(generic_chroot_support_param2); DECLARE_SYSFUNC(generic_chroot_at); DECLARE_SYSFUNC(generic_chroot_link_at); DECLARE_SYSFUNC(generic_chroot_at_link4); // Meta required functions DECLARE_SYSFUNC(mmap); #endif // SYSCALLS_H fakeroot-ng-0.18/main.cpp0000644000175000017500000001763412131747534013524 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include "arch/platform.h" #include "log.h" #include "daemon.h" static void print_version(void) { printf(PACKAGE_NAME " version " PACKAGE_VERSION "\n"); printf("This is free software. Please read the AUTHORS file for details on copyright\n" "and redistribution rights.\n"); } static void print_usage(void) { printf(PACKAGE_NAME " version " PACKAGE_VERSION "\n"); printf("Usage: fakeroot-ng [options]... command\n" "Options:\n" "-pstate\tStore persistent state\n" "-llog\tProduce debugging log operation\n" "-f\tFlush the log after each write.\n" "-d\tDo not detach\n" "-v\tPrint version information and quit\n" "-h\tShort help (this text)\n" ); } static bool nodetach=false; static const char *persistent_file; static char orig_wd[PATH_MAX]; int parse_options( int argc, char *argv[] ) { int opt; const char * logfile=NULL; bool log_flush=false; while( (opt=getopt(argc, argv, "+p:l:dvfh" ))!=-1 ) { switch( opt ) { case 'p': // Persist file persistent_file=optarg; orig_wd[0]='\0'; if( optarg[0]!='/' ) { getcwd( orig_wd, sizeof(orig_wd) ); } break; case 'l': if( logfile==NULL ) { logfile=optarg; } else { fprintf(stderr, "-l option given twice\n"); return -1; } break; case 'f': log_flush=true; break; case 'd': nodetach=true; break; case 'v': print_version(); return -2; case 'h': print_usage(); return -2; case '?': /* Error in parsing */ return -1; break; default: fprintf(stderr, "%s: internal error: unrecognized option '-%c'\n", argv[0], opt); return -1; break; } } if( log_flush && logfile==NULL ) { fprintf( stderr, "%s: -f makes no sense if -l is not also given\n", argv[0] ); return -1; } if( logfile && ! init_log( logfile, log_flush ) ) { perror( "Failed to create log file" ); return -1; } return optind; } // Make sure we are running in a sane environment static bool sanity_check() { // Make sure that /tmp (or $TMPDIR, or $FAKEROOT_TMPDIR) allow us to map executable files const char *tmp=getenv("FAKEROOT_TMPDIR"); if( tmp==NULL ) tmp=getenv("TMPDIR"); std::string tmppath; if( tmp!=NULL ) { tmppath=tmp; } else { tmppath=DEFAULT_TMPDIR; } std::auto_ptr templt(new char[tmppath.length()+20]); sprintf( templt.get(), "%s/fakeroot-ng.XXXXXX", tmppath.c_str() ); int file=mkstemp( templt.get() ); if( file==-1 ) { perror("Couldn't create temporary file"); return false; } // First - make sure we don't leave any junk behind unlink( templt.get() ); // Write some data into the file so it's not empty if( write( file, templt.get(), tmppath.length() )<0 ) { perror("Couldn't write into temporary file"); return false; } // Map the file into memory void *map=mmap( NULL, 1, PROT_EXEC|PROT_READ, MAP_SHARED, file, 0 ); int error=errno; close( file ); if( map==MAP_FAILED ) { if( error==EPERM ) { fprintf( stderr, "Temporary area points to %s, but it is mounted with \"noexec\".\n" "Set either the FAKEROOT_TMPDIR or TMPDIR environment variables to point to a\n" "directory from which executables can be run.\n", tmppath.c_str() ); } else { perror("Couldn't mmap temporary file"); } return false; } munmap( map, 1 ); return true; } static int real_perform_child( daemonCtrl &daemon_ctrl, char *argv[] ) { // Don't leave the log file open for the program to come close_log(); try { daemon_ctrl.cmd_attach(); execvp(argv[0], argv); perror("Fakeroot-ng exec failed"); } catch( const errno_exception &exception ) { fprintf(stderr, "%s: %s\n", exception.what(), exception.get_error_message() ); } catch( const std::exception &exception ) { fprintf(stderr, "Fatal error: %s\n", exception.what() ); } return 2; } #if PTLIB_PARENT_CAN_WAIT static int perform_child( daemonCtrl & daemon_ctrl, char *argv[] ) { return real_perform_child( daemon_ctrl, argv ); } #else // Parent cannot wait on debugged child #error Stale code static int perform_child( daemonCtrl & daemon_ctrl, char *argv[] ) { int pipes[2]; pipe(pipes); pid_t child=fork(); if( child<0 ) { perror("Failed to create child process"); return 2; } else if( child==0 ) { // We are the child close( pipes[0] ); return real_perform_child( daemon_ctrl, argv, pipes[1] ); } // We are the parent. close( pipes[1] ); if( debug_log!=NULL ) { fclose( debug_log ); debug_log=NULL; } int buffer; int numret; // Read from pipe to know when child finished talking to the debugger read( pipes[0], &buffer, sizeof(buffer) ); close( pipes[0] ); // Cannot "wait" for child - instead listen on socket if( (numret=read( child_socket, &buffer, sizeof(int) ))<(int)sizeof(int) ) { if( numret>=0 ) { fprintf(stderr, "Debugger terminated early\n"); } else { perror("Parent: read failed"); } exit(1); } // Why did "child" exit? if( WIFEXITED(buffer) ) { // Child has terminated. Terminate with same return code return WEXITSTATUS(buffer); } if( WIFSIGNALED(buffer) ) { // Child has terminated with a signal. return WTERMSIG(buffer); } fprintf(stderr, "Child " PID_F " terminated with unknown termination status %x\n", child, buffer ); return 3; } #endif int main(int argc, char *argv[]) { int opt_offset=parse_options( argc, argv ); if( opt_offset==-1 ) return 1; if( opt_offset==-2 ) return 0; if( opt_offset==argc ) { // Fakeroot-ng called with no arguments - assume it wanted to run the current shell // We have at least one spare argv to work with (argv[0]) - use that argv[argc-1]=getenv("SHELL"); opt_offset--; } // Check the environment to make sure it allows us to run if( !sanity_check() ) { return 1; } try { daemonCtrl daemon_ctrl(persistent_file, nodetach); return perform_child( daemon_ctrl, argv+opt_offset ); } catch( const std::exception &exception ) { fprintf( stderr, "Execution failed with error %s\n", exception.what() ); } } fakeroot-ng-0.18/missing0000755000175000017500000002623312131751664013465 0ustar sunsun#! /bin/sh # Common stub for a few missing GNU programs while installing. scriptversion=2009-04-28.21; # UTC # Copyright (C) 1996, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006, # 2008, 2009 Free Software Foundation, Inc. # Originally by Fran,cois Pinard , 1996. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program. If not, see . # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. if test $# -eq 0; then echo 1>&2 "Try \`$0 --help' for more information" exit 1 fi run=: sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p' sed_minuso='s/.* -o \([^ ]*\).*/\1/p' # In the cases where this matters, `missing' is being run in the # srcdir already. if test -f configure.ac; then configure_ac=configure.ac else configure_ac=configure.in fi msg="missing on your system" case $1 in --run) # Try to run requested program, and just exit if it succeeds. run= shift "$@" && exit 0 # Exit code 63 means version mismatch. This often happens # when the user try to use an ancient version of a tool on # a file that requires a minimum version. In this case we # we should proceed has if the program had been absent, or # if --run hadn't been passed. if test $? = 63; then run=: msg="probably too old" fi ;; -h|--h|--he|--hel|--help) echo "\ $0 [OPTION]... PROGRAM [ARGUMENT]... Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an error status if there is no known handling for PROGRAM. Options: -h, --help display this help and exit -v, --version output version information and exit --run try to run the given command, and emulate it if it fails Supported PROGRAM values: aclocal touch file \`aclocal.m4' autoconf touch file \`configure' autoheader touch file \`config.h.in' autom4te touch the output file, or create a stub one automake touch all \`Makefile.in' files bison create \`y.tab.[ch]', if possible, from existing .[ch] flex create \`lex.yy.c', if possible, from existing .c help2man touch the output file lex create \`lex.yy.c', if possible, from existing .c makeinfo touch the output file tar try tar, gnutar, gtar, then tar without non-portable flags yacc create \`y.tab.[ch]', if possible, from existing .[ch] Version suffixes to PROGRAM as well as the prefixes \`gnu-', \`gnu', and \`g' are ignored when checking the name. Send bug reports to ." exit $? ;; -v|--v|--ve|--ver|--vers|--versi|--versio|--version) echo "missing $scriptversion (GNU Automake)" exit $? ;; -*) echo 1>&2 "$0: Unknown \`$1' option" echo 1>&2 "Try \`$0 --help' for more information" exit 1 ;; esac # normalize program name to check for. program=`echo "$1" | sed ' s/^gnu-//; t s/^gnu//; t s/^g//; t'` # Now exit if we have it, but it failed. Also exit now if we # don't have it and --version was passed (most likely to detect # the program). This is about non-GNU programs, so use $1 not # $program. case $1 in lex*|yacc*) # Not GNU programs, they don't have --version. ;; tar*) if test -n "$run"; then echo 1>&2 "ERROR: \`tar' requires --run" exit 1 elif test "x$2" = "x--version" || test "x$2" = "x--help"; then exit 1 fi ;; *) if test -z "$run" && ($1 --version) > /dev/null 2>&1; then # We have it, but it failed. exit 1 elif test "x$2" = "x--version" || test "x$2" = "x--help"; then # Could not run --version or --help. This is probably someone # running `$TOOL --version' or `$TOOL --help' to check whether # $TOOL exists and not knowing $TOOL uses missing. exit 1 fi ;; esac # If it does not exist, or fails to run (possibly an outdated version), # try to emulate it. case $program in aclocal*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified \`acinclude.m4' or \`${configure_ac}'. You might want to install the \`Automake' and \`Perl' packages. Grab them from any GNU archive site." touch aclocal.m4 ;; autoconf*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified \`${configure_ac}'. You might want to install the \`Autoconf' and \`GNU m4' packages. Grab them from any GNU archive site." touch configure ;; autoheader*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified \`acconfig.h' or \`${configure_ac}'. You might want to install the \`Autoconf' and \`GNU m4' packages. Grab them from any GNU archive site." files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}` test -z "$files" && files="config.h" touch_files= for f in $files; do case $f in *:*) touch_files="$touch_files "`echo "$f" | sed -e 's/^[^:]*://' -e 's/:.*//'`;; *) touch_files="$touch_files $f.in";; esac done touch $touch_files ;; automake*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified \`Makefile.am', \`acinclude.m4' or \`${configure_ac}'. You might want to install the \`Automake' and \`Perl' packages. Grab them from any GNU archive site." find . -type f -name Makefile.am -print | sed 's/\.am$/.in/' | while read f; do touch "$f"; done ;; autom4te*) echo 1>&2 "\ WARNING: \`$1' is needed, but is $msg. You might have modified some files without having the proper tools for further handling them. You can get \`$1' as part of \`Autoconf' from any GNU archive site." file=`echo "$*" | sed -n "$sed_output"` test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` if test -f "$file"; then touch $file else test -z "$file" || exec >$file echo "#! /bin/sh" echo "# Created by GNU Automake missing as a replacement of" echo "# $ $@" echo "exit 0" chmod +x $file exit 1 fi ;; bison*|yacc*) echo 1>&2 "\ WARNING: \`$1' $msg. You should only need it if you modified a \`.y' file. You may need the \`Bison' package in order for those modifications to take effect. You can get \`Bison' from any GNU archive site." rm -f y.tab.c y.tab.h if test $# -ne 1; then eval LASTARG="\${$#}" case $LASTARG in *.y) SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'` if test -f "$SRCFILE"; then cp "$SRCFILE" y.tab.c fi SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'` if test -f "$SRCFILE"; then cp "$SRCFILE" y.tab.h fi ;; esac fi if test ! -f y.tab.h; then echo >y.tab.h fi if test ! -f y.tab.c; then echo 'main() { return 0; }' >y.tab.c fi ;; lex*|flex*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified a \`.l' file. You may need the \`Flex' package in order for those modifications to take effect. You can get \`Flex' from any GNU archive site." rm -f lex.yy.c if test $# -ne 1; then eval LASTARG="\${$#}" case $LASTARG in *.l) SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'` if test -f "$SRCFILE"; then cp "$SRCFILE" lex.yy.c fi ;; esac fi if test ! -f lex.yy.c; then echo 'main() { return 0; }' >lex.yy.c fi ;; help2man*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified a dependency of a manual page. You may need the \`Help2man' package in order for those modifications to take effect. You can get \`Help2man' from any GNU archive site." file=`echo "$*" | sed -n "$sed_output"` test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` if test -f "$file"; then touch $file else test -z "$file" || exec >$file echo ".ab help2man is required to generate this page" exit $? fi ;; makeinfo*) echo 1>&2 "\ WARNING: \`$1' is $msg. You should only need it if you modified a \`.texi' or \`.texinfo' file, or any other file indirectly affecting the aspect of the manual. The spurious call might also be the consequence of using a buggy \`make' (AIX, DU, IRIX). You might want to install the \`Texinfo' package or the \`GNU make' package. Grab either from any GNU archive site." # The file to touch is that specified with -o ... file=`echo "$*" | sed -n "$sed_output"` test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` if test -z "$file"; then # ... or it is the one specified with @setfilename ... infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'` file=`sed -n ' /^@setfilename/{ s/.* \([^ ]*\) *$/\1/ p q }' $infile` # ... or it is derived from the source name (dir/f.texi becomes f.info) test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info fi # If the file does not exist, the user really needs makeinfo; # let's fail without touching anything. test -f $file || exit 1 touch $file ;; tar*) shift # We have already tried tar in the generic part. # Look for gnutar/gtar before invocation to avoid ugly error # messages. if (gnutar --version > /dev/null 2>&1); then gnutar "$@" && exit 0 fi if (gtar --version > /dev/null 2>&1); then gtar "$@" && exit 0 fi firstarg="$1" if shift; then case $firstarg in *o*) firstarg=`echo "$firstarg" | sed s/o//` tar "$firstarg" "$@" && exit 0 ;; esac case $firstarg in *h*) firstarg=`echo "$firstarg" | sed s/h//` tar "$firstarg" "$@" && exit 0 ;; esac fi echo 1>&2 "\ WARNING: I can't seem to be able to run \`tar' with the given arguments. You may want to install GNU tar or Free paxutils, or check the command line arguments." exit 1 ;; *) echo 1>&2 "\ WARNING: \`$1' is needed, and is $msg. You might have modified some files without having the proper tools for further handling them. Check the \`README' file, it often tells you about the needed prerequisites for installing this package. You may also peek at any GNU archive site, in case some other package would contain this missing \`$1' program." exit 1 ;; esac exit 0 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC" # time-stamp-end: "; # UTC" # End: fakeroot-ng-0.18/file.cpp0000644000175000017500000015730412130614054013503 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include #include #include "syscalls.h" #include "file_lie.h" #include "chroot.h" #include "arch/platform.h" // Helper function - fill in an override structure from a stat structure static void stat_override_copy( const ptlib_stat *stat, stat_override *override ) { override->dev=stat->dev; override->inode=stat->ino; override->uid=stat->uid; override->gid=stat->gid; override->dev_id=stat->rdev; override->mode=stat->mode; } // Same function for stat, lstat and fstat bool sys_stat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); // Entering the syscall state->state=pid_state::RETURN; state->context_state[0]=ptlib_get_argument( pid, 2 ); // Store the pointer to the stat struct dlog("stat64: " PID_F " stored pointer at %p\n", pid, (void*)state->context_state[0] ); // If the process is chrooted, we need to translate the file name int real_sc=ptlib_get_syscall( pid ); if( ( real_sc==PREF_STAT || real_sc==PREF_LSTAT ) ) { chroot_translate_param( pid, state, 1, real_sc!=PREF_LSTAT ); } } else if( state->state==pid_state::RETURN ) { // Returning from the syscall int returncode=ptlib_get_retval( pid ); dlog("stat64: " PID_F " returned %x\n", pid, returncode); try { if( ptlib_success( pid, sc_num ) ) { struct ptlib_stat ret; struct stat_override override; if( !ptlib_get_mem( pid, state->context_state[0], &ret, sizeof(ret) ) ) // Probably page fault - report the error throw (int)errno; if( get_map( ret.dev, ret.ino, &override ) ) { bool ok=true; ret.uid=override.uid; ret.gid=override.gid; if( S_ISBLK(override.mode) || S_ISCHR(override.mode) ) { // Only turn regular files into devices if( !S_ISREG( ret.mode ) ) ok=false; ret.rdev=override.dev_id; } else { // If the override is not a device, and the types do not match, this is not a valid entry ok=(S_IFMT&ret.mode)==(S_IFMT&override.mode); } // Override the u=x flag for directories, but not files if( S_ISDIR(ret.mode) ) { ret.mode=(ret.mode&(~(07700|S_IFMT))) | (override.mode&(07700|S_IFMT)); } else { ret.mode=(ret.mode&(~(07600|S_IFMT))) | (override.mode&(07600|S_IFMT)); } if( ok ) { dlog("stat64: " PID_F " override dev=" DEV_F " inode=" INODE_F " mode=%o uid=" UID_F " gid=" GID_F "\n", pid, ret.dev, ret.ino, ret.mode, ret.uid, ret.gid ); if( !ptlib_set_mem( pid, &ret, state->context_state[0], sizeof(struct stat) ) ) { // Probably page fault - report the error throw (int)errno; // No need to remove the map - it is legitimate } } else { dlog("stat64: " PID_F " dev=" DEV_F " inode=" INODE_F " override entry corrupt - removed\n", pid, ret.dev, ret.ino ); remove_map( ret.dev, ret.ino ); } } } } catch( int error ) { ptlib_set_error( pid, state->orig_sc, error ); } state->state=pid_state::NONE; } return true; } #if HAVE_OPENAT bool sys_fstatat64( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); // Entering the syscall state->state=pid_state::RETURN; chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, (ptlib_get_argument(pid, 4)&AT_SYMLINK_NOFOLLOW)!=0 ); state->context_state[0]=ptlib_get_argument( pid, 3 ); // Store the pointer to the stat struct dlog("statat64: " PID_F " stored pointer at %p\n", pid, (void*)state->context_state[0] ); return true; } else { return sys_stat( sc_num, pid, state ); // Return code handling is the same as for the regular stat } } #endif static bool real_chmod( int sc_num, pid_t pid, pid_state *state, int mode_offset, int stat_function, int extra_flags=-1 ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); // First we stat the file to find out what we are up against (dev/inode etc.) state->state=pid_state::REDIRECT2; state->orig_sc=sc_num; state->context_state[1]=ptlib_get_argument( pid, mode_offset+1 ); // Store the requested mode state->context_state[0]=0; // syscall parts progress ptlib_set_argument( pid, mode_offset+1, state->mem->get_mem() ); // where to store the stat result // one anomaly handled with special case. ugly, but not worth the interface complication if( extra_flags!=-1 ) { // some of the functions require an extra flag after the usual parameters dlog("real_chmod: set arg2 to %d\n", extra_flags); ptlib_set_argument( pid, mode_offset+2, extra_flags ); } ptlib_set_syscall( pid, stat_function ); } else if( state->state==pid_state::REDIRECT2 && state->context_state[0]==0 ) { if( ptlib_success( pid, sc_num ) ) { // Our stat succeeded struct stat_override override; struct ptlib_stat stat; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } ptlib_save_state( pid, state->saved_state ); // Restore the original parameters to restart the actual chmod call for( int i=1; i<=mode_offset; ++i ) ptlib_set_argument( pid, i, state->context_state[i+1] ); // one anomaly handled with special case. ugly, but not worth the interface complication if( extra_flags!=-1 ) { // some of the functions require an extra flag after the usual parameters ptlib_set_argument( pid, mode_offset+2, extra_flags ); } state->state=pid_state::REDIRECT1; // Modify the chmod mode mode_t mode=(mode_t)state->context_state[1]; mode&=~07000; // Clear the SUID etc. bits if( S_ISDIR( stat.mode ) ) { // The node in question is a directory mode|=00700; // Make sure we have read, write and execute permission } else { // Node is not a directory mode|=00600; // Set read and write for owner } ptlib_set_argument( pid, mode_offset+1, mode ); // Save the stuff we'll need in order to update the lies database state->context_state[2]=stat.dev; state->context_state[3]=stat.ino; state->context_state[0]=1; // Mark this as the actual chmod call // If we don't already have an entry for this file in the lies database, we will not have // the complete stat struct later on to create it. if( !get_map( stat.dev, stat.ino, &override ) ) { // Create a lie that is identical to the actual file stat_override_copy( &stat, &override ); set_map( &override ); } return ptlib_generate_syscall( pid, state->orig_sc, state->mem->get_shared() ); } else { // stat failed - return that failure to the caller as is state->state=pid_state::NONE; } } else if( state->state==pid_state::REDIRECT2 && state->context_state[0]==1 ) { if( ptlib_success( pid, sc_num ) ) { // The chmod call succeeded - update the lies database struct stat_override override; if( !get_map( state->context_state[2], state->context_state[3], &override ) ) { // We explicitly created this map not so long ago - something is wrong // XXX What can we do except hope these are reasonable values override.dev=state->context_state[2]; override.inode=state->context_state[3]; override.uid=0; override.gid=0; override.dev_id=0; override.transient=true; dlog("chmod: " PID_F " error (race?) getting override info for dev " DEV_F " inode " INODE_F "\n", pid, (dev_t)state->context_state[2], (ptlib_inode_t)state->context_state[3] ); } override.mode=(override.mode&~07777)|(((mode_t)state->context_state[1])&07777); dlog("chmod: " PID_F " Setting override mode %o dev " DEV_F " inode " INODE_F "\n", pid, override.mode, override.dev, override.inode ); set_map( &override ); ptlib_restore_state( pid, state->saved_state ); ptlib_set_retval( pid, 0 ); } else { // We just need to restore the saved state but keep the chmod error code int err=ptlib_get_error( pid, sc_num ); ptlib_restore_state( pid, state->saved_state ); ptlib_set_error( pid, sc_num, err ); } state->state=pid_state::NONE; } else { dlog("chmod: " PID_F " unknown state %d\n", pid, state->state ); } return true; } // The actual work is done by "real_chmod". bool sys_chmod( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 1, true ); state->context_state[2]=ptlib_get_argument( pid, 1 ); // Store the file name } return real_chmod( sc_num, pid, state, 1, PREF_STAT ); } bool sys_fchmod( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { state->context_state[2]=ptlib_get_argument( pid, 1 ); // Store the file descriptor } return real_chmod( sc_num, pid, state, 1, PREF_FSTAT ); } #if HAVE_OPENAT bool sys_fchmodat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); // XXX At some potential future date, Linux may implement AT_SYMLINK_NOFOLLOW, at which point // this chroot translation will need to be reconsidered chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1), 2, true ); state->context_state[2]=ptlib_get_argument( pid, 1 ); // Store the base dir fd state->context_state[3]=ptlib_get_argument( pid, 2 ); // Store the file name state->context_state[4]=ptlib_get_argument( pid, 4 ); // Store the flags } return real_chmod( sc_num, pid, state, 2, PREF_FSTATAT, 0 ); } #endif // context_state[0] and 1 should contain the desired uid and gid respectively static bool real_chown( int sc_num, pid_t pid, pid_state *state, int own_offset, int stat_function, int extra_flags=-1 ) { // XXX Do we handle the mode change following a chown (file and directory) correctly? if( state->state==pid_state::NONE ) { // Map this to a stat operation ptlib_set_argument( pid, own_offset+1, state->mem->get_mem() ); if( extra_flags!=-1 ) { ptlib_set_argument( pid, own_offset+2, extra_flags ); } ptlib_set_syscall( pid, stat_function ); dlog("chown: " PID_F " redirected chown call to stat\n", pid ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { if( ptlib_success( pid, sc_num ) ) { struct ptlib_stat stat; struct stat_override override; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This is a syscall we initiated, to a memory buffer we own. It should not have failed. assert(0); } if( !get_map( stat.dev, stat.ino, &override ) ) { dlog("chown: " PID_F " no override for file - create a new one\n", pid ); stat_override_copy( &stat, &override ); } if( ((int)state->context_state[0])!=-1 ) override.uid=state->context_state[0]; if( ((int)state->context_state[1])!=-1 ) override.gid=state->context_state[1]; dlog("chown: " PID_F " changing owner of dev " DEV_F " inode " INODE_F "\n", pid, override.dev, override.inode ); set_map( &override ); } else { dlog("chown: " PID_F " stat call failed with error %s\n", pid, strerror(ptlib_get_error(pid, sc_num)) ); } state->state=pid_state::NONE; } return true; } bool sys_chown( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=ptlib_get_argument(pid, 2); state->context_state[1]=ptlib_get_argument(pid, 3); chroot_translate_param( pid, state, 1, true ); } return real_chown( sc_num, pid, state, 1, PREF_STAT ); } bool sys_fchown( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=ptlib_get_argument(pid, 2); state->context_state[1]=ptlib_get_argument(pid, 3); } return real_chown( sc_num, pid, state, 1, PREF_FSTAT ); } bool sys_lchown( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=ptlib_get_argument(pid, 2); state->context_state[1]=ptlib_get_argument(pid, 3); chroot_translate_param( pid, state, 1, false ); } return real_chown( sc_num, pid, state, 1, PREF_LSTAT ); } #if HAVE_OPENAT bool sys_fchownat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=ptlib_get_argument(pid, 3); state->context_state[1]=ptlib_get_argument(pid, 4); state->context_state[2]=ptlib_get_argument(pid, 5); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, (state->context_state[2]&AT_SYMLINK_NOFOLLOW)!=0 ); } return real_chown( sc_num, pid, state, 2, PREF_FSTATAT, state->context_state[2] ); } #endif static bool real_mknod( int sc_num, pid_t pid, pid_state *state, int mode_offset, int stat_function, int extra_flags=-1 ) { if( state->state==pid_state::NONE ) { mode_t mode=(mode_t)state->context_state[0]; // Remove SUID and add user read and write mode&=~07000; mode|= 00600; if( S_ISCHR(mode) || S_ISBLK(mode) ) { dlog("mknod: " PID_F " tried to create %s device, turn to regular file\n", pid, S_ISCHR(mode) ? "character" : "block" ); mode=(mode&~S_IFMT) | S_IFREG; } ptlib_set_argument( pid, mode_offset+1, mode ); dlog("mknod: %d mode %o\n", pid, (unsigned int)state->context_state[1] ); state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { if( ptlib_success( pid, sc_num ) ) { // Need to call "stat" on the file to see what inode number it got ptlib_save_state( pid, state->saved_state ); for( int i=0; icontext_state[2+i] ); // File name etc. } ptlib_set_argument( pid, mode_offset+1, state->mem->get_mem() ); // Struct stat if( extra_flags!=-1 ) { ptlib_set_argument( pid, mode_offset+2, extra_flags ); } state->state=pid_state::REDIRECT1; dlog("mknod: " PID_F " Actual node creation successful. Calling stat\n", pid ); return ptlib_generate_syscall( pid, stat_function, state->mem->get_shared() ); } else { // Nothing to do if the call failed dlog("mknod: " PID_F " call failed with error %s\n", pid, strerror(ptlib_get_error(pid, sc_num) ) ); } } else if( state->state==pid_state::REDIRECT2 ) { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; stat_override override; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof(stat) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } // This file was, supposedly, just created. Even if it has an entry in the override DB, that entry is obsolete stat_override_copy( &stat, &override ); // We created the file, it should have our uid/gid override.uid=state->fsuid; override.gid=state->fsgid; dlog("mknod: " PID_F " registering the new device in the override DB dev " DEV_F " inode " INODE_F "\n", pid, stat.dev, stat.ino ); mode_t mode=(mode_t)state->context_state[0]; if( S_ISCHR(mode) || S_ISBLK(mode) || (mode&07000)!=0) { dlog("mknod: " PID_F " overriding the file type and/or mode\n", pid ); override.mode=(override.mode&~(S_IFMT|07000)) | (mode&(S_IFMT|07000)); override.dev_id=(dev_t)state->context_state[1]; } // use the user read+write from the original, not the actual file // XXX This code disregards the umask override.mode&=~00600; override.mode|= mode&00600; set_map( &override ); } else { // mknod succeeded, but stat failed? dlog("mknod: " PID_F " stat failed. Leave override DB non-updated\n", pid ); } ptlib_restore_state( pid, state->saved_state ); state->state=pid_state::NONE; } return true; } bool sys_mknod( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 1, false ); state->context_state[0]=ptlib_get_argument( pid, 2 ); // Mode state->context_state[1]=ptlib_get_argument( pid, 3 ); // Device ID state->context_state[2]=ptlib_get_argument( pid, 1 ); // File name } return real_mknod( sc_num, pid, state, 1, PREF_STAT ); } #if HAVE_OPENAT bool sys_mknodat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, false ); state->context_state[0]=ptlib_get_argument( pid, 3 ); // Mode state->context_state[1]=ptlib_get_argument( pid, 4 ); // Device ID state->context_state[2]=ptlib_get_argument( pid, 1 ); // Base fd state->context_state[3]=ptlib_get_argument( pid, 2 ); // File name } return real_mknod( sc_num, pid, state, 1, PREF_FSTATAT, 0 ); } #endif static bool real_open( int sc_num, pid_t pid, pid_state *state, int mode_argnum ) { if( state->state==pid_state::NONE ) { if( (state->context_state[0]&O_CREAT)!=0 ) { // We are asking to create the file - make sure we give user read and write permission state->context_state[1]=ptlib_get_argument( pid, mode_argnum ); mode_t mode=state->context_state[1]; // Remove SUID and add user read and write permission mode&=~07000; mode|= 00600; if( mode!=state->context_state[1] ) { ptlib_set_argument( pid, mode_argnum, mode ); } } state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { // Did we request to create a new file? if( (state->context_state[0]&O_CREAT)!=0 && ptlib_success(pid, sc_num) ) { int fd=(long)ptlib_get_retval(pid); dlog("open: " PID_F " opened fd %d, assume we actually created it\n", pid, fd ); ptlib_save_state( pid, state->saved_state ); state->state=pid_state::REDIRECT1; // Call fstat to find out what we have ptlib_set_argument( pid, 1, fd ); ptlib_set_argument( pid, 2, state->mem->get_mem() ); return ptlib_generate_syscall( pid, PREF_FSTAT, state->mem->get_shared() ); } else state->state=pid_state::NONE; } else if( state->state==pid_state::REDIRECT2 ) { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; stat_override override; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } // XXX The test whether we just created a new file is not the most accurate in the world // In particular, if the previous instance was deleted, this will misbehave // Fixed: if the previous instance was deleted BY US, this should now be ok // Still, /dev/null is routinely found in the map for no good reason due to this code if( !get_map( stat.dev, stat.ino, &override ) || override.transient ) { // If the map already exists, assume we did not create a new file and don't touch the owners stat_override_copy( &stat, &override ); override.uid=state->fsuid; override.gid=state->fsgid; override.mode&=~07600; override.mode|= state->context_state[1]&07600; // XXX We are ignoring the umask here! set_map( &override ); dlog("open: " PID_F " creating override for dev " DEV_F " inode " INODE_F "\n", pid, override.dev, override.inode); } else { dlog("open: " PID_F " map for dev " DEV_F " inode " INODE_F " already exists - doing nothing\n", pid, stat.dev, stat.ino ); } } else { dlog("open: " PID_F " fstat failed %s\n", pid, strerror( ptlib_get_error( pid, sc_num ) ) ); } state->state=pid_state::NONE; ptlib_restore_state( pid, state->saved_state ); } return true; } bool sys_open( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 1, true ); state->context_state[0]=ptlib_get_argument( pid, 2 ); //flags } return real_open( sc_num, pid, state, 3 ); } #if HAVE_OPENAT bool sys_openat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, true ); state->context_state[0]=ptlib_get_argument( pid, 3 ); //flags } return real_open( sc_num, pid, state, 4 ); } #endif static bool real_mkdir( int sc_num, pid_t pid, pid_state *state, int mode_offset, int stat_function, int extra_flags=-1 ) { if( state->state==pid_state::NONE ) { // Make sure user has rwx on the created directory state->context_state[0]=ptlib_get_argument( pid, mode_offset+1 ); mode_t mode=state->context_state[0]; mode|= 00700; if( mode!=state->context_state[0] ) { // We did change the mode ptlib_set_argument( pid, mode_offset+1, mode ); } state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; if( ptlib_success( pid, sc_num ) ) { dlog("mkdir: " PID_F " succeeded. Call stat\n", pid ); ptlib_save_state( pid, state->saved_state ); // Perform a stat operation so we can know the directory's dev and inode for( int i=1; i<=mode_offset; ++i ) ptlib_set_argument( pid, i, state->context_state[i] ); // The original mkdir arguments ptlib_set_argument( pid, mode_offset+1, state->mem->get_mem() ); // stat structure if( extra_flags!=-1 ) { ptlib_set_argument( pid, mode_offset+2, extra_flags ); } state->orig_sc=sc_num; state->state=pid_state::REDIRECT1; return ptlib_generate_syscall( pid, stat_function, state->mem->get_shared() ); } else { // If mkdir failed, we don't have anything else to do. dlog("mkdir: " PID_F " failed with error %s\n", pid, strerror(ptlib_get_error( pid, sc_num ) ) ); } } else if( state->state==pid_state::REDIRECT2 ) { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; stat_override override; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } // Since mkdir fails if the directory already exists, there is no point to check whether the override already exists stat_override_copy( &stat, &override ); override.uid=state->fsuid; override.gid=state->fsgid; override.mode&=~00700; override.mode|= state->context_state[0]&00700; // XXX This code does not take the umask into account dlog("mkdir: " PID_F " storing override for dev " DEV_F " inode " INODE_F "\n", pid, override.dev, override.inode); set_map( &override ); } else { dlog("mkdir: " PID_F " stat failed with error %s\n", pid, strerror(ptlib_get_error(pid, sc_num))); } ptlib_restore_state( pid, state->saved_state ); state->state=pid_state::NONE; } return true; } bool sys_mkdir( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 1, true ); state->context_state[1]=ptlib_get_argument( pid, 1 ); // Directory name if( log_level>0 ) { char name[PATH_MAX]; ptlib_get_string( pid, state->context_state[0], name, sizeof(name) ); dlog("mkdir: %d creates %s\n", pid, name ); } } return real_mkdir( sc_num, pid, state, 1, PREF_STAT ); } #if HAVE_OPENAT bool sys_mkdirat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, true ); state->context_state[1]=ptlib_get_argument( pid, 1 ); // File descriptor state->context_state[2]=ptlib_get_argument( pid, 2 ); // Directory name if( log_level>0 ) { char name[PATH_MAX]; ptlib_get_string( pid, state->context_state[2], name, sizeof(name) ); int fd=(int)state->context_state[1]; dlog("mkdirat: %d creates %s at %x\n", pid, name, fd ); } } return real_mkdir( sc_num, pid, state, 2, PREF_FSTATAT, 0 ); } #endif static bool real_symlink( int sc_num, pid_t pid, pid_state *state, int mode_offset, int stat_function, int extra_flags=-1 ) { if( state->state==pid_state::NONE ) { state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { if( ptlib_success( pid, sc_num ) ) { dlog("symlink: " PID_F " success. Call stat to mark uid/gid override\n", pid ); ptlib_save_state( pid, state->saved_state ); for( int i=0; icontext_state[i] ); // File name } ptlib_set_argument( pid, mode_offset+1, state->mem->get_mem() ); // stat structure if( extra_flags!=-1 ) { ptlib_set_argument( pid, mode_offset+2, extra_flags ); } state->state=pid_state::REDIRECT1; return ptlib_generate_syscall( pid, stat_function, state->mem->get_shared() ); } else { dlog("symlink: " PID_F " failed with error %s\n", pid, strerror( ptlib_get_error(pid, sc_num) ) ); state->state=pid_state::NONE; } } else if( state->state==pid_state::REDIRECT2 ) { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; stat_override override; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } // Make sure we got the right file if( S_ISLNK(stat.mode) ) { // No need to check the DB as we just created the file stat_override_copy( &stat, &override ); override.uid=state->fsuid; override.gid=state->fsgid; dlog("symlink: " PID_F " set uid/gid override for dev " DEV_F " inode " INODE_F "\n", pid, override.dev, override.inode ); set_map( &override ); } else { dlog("symlink: " PID_F " acutal file on disk is not a symlink. Type %o dev " DEV_F " inode " INODE_F "\n", pid, stat.mode, stat.dev, stat.ino ); } } else { dlog("symlink: " PID_F " symlink succeeded, but stat failed with %s\n", pid, strerror(ptlib_get_error(pid, sc_num))); } ptlib_restore_state( pid, state->saved_state ); state->state=pid_state::NONE; } return true; } bool sys_symlink( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 2, false ); state->context_state[0]=ptlib_get_argument( pid, 2 ); // new path } return real_symlink( sc_num, pid, state, 1, PREF_LSTAT ); } #if HAVE_OPENAT bool sys_symlinkat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 2 ), 3, false ); state->context_state[0]=ptlib_get_argument( pid, 2 ); // dirfd state->context_state[1]=ptlib_get_argument( pid, 3 ); // new path } return real_symlink( sc_num, pid, state, 2, PREF_FSTATAT, AT_SYMLINK_NOFOLLOW ); } #endif bool sys_getcwd( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; // If the process is chrooted, we need to translate the directory name if( chroot_is_chrooted(state) ) { // We don't want to report the real current directory, of course! state->context_state[0]=ptlib_get_argument( pid, 1 ); // Buffer state->context_state[1]=ptlib_get_argument( pid, 2 ); // Buffer len // Perform the actual call into our buffer ptlib_set_argument( pid, 1, state->mem->get_mem() ); ptlib_set_argument( pid, 2, PATH_MAX ); } } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; if( ptlib_success( pid, sc_num ) && chroot_is_chrooted(state) ) { // We are inside a chroot, and the call was successful char buffer[PATH_MAX]; ptlib_get_string( pid, state->mem->get_mem(), buffer, sizeof(buffer) ); char tmp=buffer[state->root->length()]; buffer[state->root->length()]='\0'; char *ptr=buffer; if( ( tmp=='/' || tmp=='\0' ) && *state->root==buffer ) { // Current directory is inside the chroot jail - need to truncate the prefix if( tmp=='/' ) { ptr+=state->root->length(); *ptr=tmp; } else { // The current directory is the new root strcpy( buffer, "/" ); } } else { // Current directory is outside of the jail - pass it to the program as is buffer[state->root->length()]=tmp; } // Emulate the actual call size_t len=strlen(ptr); if( lencontext_state[1] ) { // Buffer is large enough ptlib_set_string( pid, ptr, state->context_state[0] ); ptlib_set_retval( pid, len+1 ); } else { // The buffer is not large enough ptlib_set_error( pid, sc_num, ERANGE ); } } } return true; } bool sys_munmap( int sc_num, pid_t pid, pid_state *state ) { // XXX Does this work? We should never be called with REDIRECT1 if( state->state==pid_state::NONE || state->state==pid_state::REDIRECT1 ) { if( state->state==pid_state::NONE ) { // This is our first time entering this munmap state->context_state[2]=0; // No state to restore } state->state=pid_state::RETURN; state->context_state[0]=0; // 0 is the next start address to unmap, 1 is the new length state->context_state[1]=0; // len=0 means we have no more mmaps to perform // Is this an attempt to release one of the memory areas we own? int_ptr start=ptlib_get_argument( pid, 1 ); int_ptr end=start+ptlib_get_argument( pid, 2 ); // If end wraps around then the kernel will fail this anyways // Same goes if the page size is not aligned or the length is zero if( start>end || (start%sysconf(_SC_PAGESIZE))!=0 || start==end ) // XXX We still need to fail this ourselves, just to make sure return true; // Put the lower of the two addreses in addr1 int_ptr addr1=state->mem->get_shared(), addr2=state->mem->get_mem(); size_t len1=static_mem_size, len2=shared_mem_size-ptlib_prepare_memory_len(); const char *name1="static", *name2="shared"; if( addr1>addr2 ) { int_ptr tmp=addr1; addr1=addr2; addr2=tmp; size_t tmplen=len1; len1=len2; len2=tmplen; const char *tmpname=name1; name1=name2; name2=tmpname; } state->state=pid_state::REDIRECT2; if( startaddr1 ) { // The unmap range covers the lower range dlog("sys_munmap: " PID_F " tried to unmap range %p-%p, which conflicts with our %s range %p-%p\n", pid, (void*)start, (void*)end, name1, (void*)addr1, (void*)(addr1+len1) ); if( end>addr1+len1 ) { // There is an area to unmap above the lower range - mark it for a second syscall state->context_state[0]=addr1+len1; state->context_state[1]=end-state->context_state[0]; } end=addr1; } else if( start>=addr1 && startaddr2 ) { // The unmap area covers the upper memory range dlog("sys_munmap: " PID_F " tried to unmap range %p-%p, which conflicts with our %s range %p-%p\n", pid, (void*)start, (void*)end, name2, (void*)addr2, (void*)(addr2+len2) ); if( end>addr2+len2 ) { // There is an area to unmap above the upper range - mark it for a second (third?) syscall state->context_state[0]=addr2+len2; state->context_state[1]=end-state->context_state[0]; } end=addr2; } else if( start>=addr2 && startstate=pid_state::RETURN; return true; } // We had to change the parameters because of an overlap ptlib_set_argument( pid, 1, start ); ptlib_set_argument( pid, 2, end-start ); } else if( state->state==pid_state::RETURN || state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; if( ptlib_success( pid, sc_num ) ) { bool last=(state->context_state[1]==0); // If we are not done yet, we will need to store this position and come back to it if( state->context_state[2]==0 && !last ) { ptlib_save_state( pid, state->saved_state ); state->context_state[2]=1; } if( !last ) { // We split the munmap into several calls - there are more calls to perform // Use REDIRECT3 rather than NONE so that strace won't see the extra call state->state=pid_state::REDIRECT3; ptlib_set_argument( pid, 1, state->context_state[0] ); ptlib_set_argument( pid, 2, state->context_state[1] ); return ptlib_generate_syscall( pid, sc_num, state->mem->get_shared() ); } } else { // The syscall failed - we will end it here even if we thought we had something more to do dlog("sys_munmap: " PID_F " failed: %s\n", pid, strerror(ptlib_get_error(pid, sc_num))); } if( state->context_state[2]==1 ) { ptlib_restore_state( pid, state->saved_state ); } } return true; } bool sys_link( int sc_num, pid_t pid, pid_state *state ) { // XXX lock memory if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; // Translate the "oldpath" chroot_translate_param( pid, state, 1, false, false, 0 ); // Translate the "newpath" chroot_translate_param( pid, state, 2, false, false, PATH_MAX ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } #if HAVE_OPENAT bool sys_linkat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; // Translate the "oldpath" chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1), 2, (ptlib_get_argument( pid, 5)&AT_SYMLINK_FOLLOW)==0, false, 0 ); // Translate the "newpath" chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 3), 4, false, false, PATH_MAX ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } #endif // In this function, context_state holds: // 0 - state machine for redirected syscalls // 1 - forced error number // 2 - pointer to file name // // after the lstat stage: // 2 - 0: just delete. 1: need to mark for deletion from the override db as well bool sys_unlink( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=0; // Beginning of syscall state->context_state[1]=0; // No forced error if( chroot_is_chrooted( state ) ) { // Translate the filename. If the last path component is a symlink, that is what we want deleted if( !chroot_translate_param( pid, state, 1, false, true ) ) { // We had an error translating the file name - pass the error on state->state=pid_state::REDIRECT2; state->context_state[1]=errno; ptlib_set_syscall(pid, PREF_NOP); return true; } } // Keep a copy of the file name state->context_state[2]=ptlib_get_argument( pid, 1 ); // We need to know whether the file was, indeed, deleted. One method goes like this // First, open the file. Next, unlink the file. Then, fstat the file. // Problem - cannot do that for symbolic links. // // Second method - lstat the file before, unlink. If link count before was 1, inode // is no more. // Problem - someone else may have linked it while between the lstat and the unlink. // // Third method - link the file to a temporary name, unlink the original, check link // count on temporary name. // Problem - not easy to translate relative name to one that can be used from another // process. On Linux, we do that using "linkat" // We now implement the second method ptlib_set_syscall( pid, PREF_LSTAT ); ptlib_set_argument( pid, 2, state->mem->get_mem() ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; if( state->context_state[1]!=0 ) { // We need to force an error ptlib_set_error( pid, state->orig_sc, state->context_state[1] ); state->state=pid_state::NONE; return true; } // Handle the actual state machine switch( state->context_state[0] ) { case 0: // lstat returned { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } if( stat.nlink==1 ) { // Store the relevant data in the shared memory struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); key->dev=stat.dev; key->inode=stat.ino; state->context_state[2]=1; } else { state->context_state[2]=0; } // Perform the actual unlink operation ptlib_save_state( pid, state->saved_state ); ptlib_generate_syscall( pid, state->orig_sc, state->mem->get_shared() ); state->state=pid_state::REDIRECT1; state->context_state[0]=1; } else { // lstat syscall failed - pass the error along state->state=pid_state::NONE; dlog("%s: " PID_F " lstat failed with error: %s\n", __FUNCTION__, pid, strerror(ptlib_get_error(pid, sc_num))); } } break; case 1: // unlink returned { bool success=ptlib_success( pid, sc_num ); int error=success?0:ptlib_get_error( pid, sc_num ); ptlib_restore_state( pid, state->saved_state ); if( success ) { if( state->context_state[2]==1 ) { // Need to erase the override from our database struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); stat_override map; if( get_map( key->dev, key->inode, &map ) ) { map.transient=true; set_map( &map ); dlog("sys_unlink: " PID_F " inode " INODE_F " in override mapping marked transient\n", pid, key->inode ); } } } else { // The "restore state" command overwrote the error ptlib_set_error( pid, sc_num, error ); dlog("%s: " PID_F " unlink failed with error: %s\n", __FUNCTION__, pid, strerror(error)); } } break; } } return true; } #if HAVE_OPENAT // In this function, context_state holds: // 0 - state machine for redirected syscalls // 1 - forced error number // 2 - pointer to file name // // after the lstat stage: // 2 - 0: just delete. 1: need to mark for deletion from the override db as well // // XXX Some code duplication with above function bool sys_unlinkat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->context_state[0]=(ptlib_get_argument(pid, 3)&AT_REMOVEDIR)==0 ? 0 : 10; // Beginning of syscall state->context_state[1]=0; // No forced error if( chroot_is_chrooted( state ) ) { // Translate the filename. If the last path component is a symlink, that is what we want deleted if( !chroot_translate_paramat( pid, state, ptlib_get_argument(pid, 1), 2, false, true ) ) { // We had an error translating the file name - pass the error on state->state=pid_state::REDIRECT2; state->context_state[1]=errno; ptlib_set_syscall(pid, PREF_NOP); return true; } } // Keep a copy of the file name state->context_state[2]=ptlib_get_argument( pid, 1 ); state->context_state[3]=ptlib_get_argument( pid, 2 ); // We need to know whether the file was, indeed, deleted. One method goes like this // First, open the file. Next, unlink the file. Then, fstat the file. // Problem - cannot do that for symbolic links. // // Second method - lstat the file before, unlink. If link count before was 1, inode // is no more. // Problem - someone else may have linked it while between the lstat and the unlink. // // Third method - link the file to a temporary name, unlink the original, check link // count on temporary name. // Problem - not easy to translate relative name to one that can be used from another // process. On Linux, we do that using "linkat" // We now implement the second method ptlib_set_syscall( pid, PREF_FSTATAT ); ptlib_set_argument( pid, 3, state->mem->get_mem() ); ptlib_set_argument( pid, 4, AT_SYMLINK_NOFOLLOW ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { state->state=pid_state::NONE; if( state->context_state[1]!=0 ) { // We need to force an error ptlib_set_error( pid, state->orig_sc, state->context_state[1] ); state->state=pid_state::NONE; return true; } // Handle the actual state machine switch( state->context_state[0] ) { case 0: case 10: // lstat returned { if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; // We are tight on context memory - first set up the args for the continuation syscall, // only then handle the current call return ptlib_save_state( pid, state->saved_state ); ptlib_set_argument( pid, 1, state->context_state[2] ); ptlib_set_argument( pid, 2, state->context_state[3] ); ptlib_set_argument( pid, 3, state->context_state[0]==10 ? AT_REMOVEDIR : 0 ); // Will the file be actually deleted? if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } if( stat.nlink==1 || state->context_state[0]==10 ) { // Store the relevant data in the shared memory struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); key->dev=stat.dev; key->inode=stat.ino; state->context_state[2]=1; } else { state->context_state[2]=0; } // Complete the continuation call ptlib_generate_syscall( pid, state->orig_sc, state->mem->get_shared() ); state->state=pid_state::REDIRECT1; state->context_state[0]=1; } else { // lstat syscall failed - pass the error along state->state=pid_state::NONE; dlog("%s: " PID_F " fstatat failed with error: %s\n", __FUNCTION__, pid, strerror(ptlib_get_error(pid, sc_num))); } } break; case 1: // unlink returned { bool success=ptlib_success( pid, sc_num ); int error=success?0:ptlib_get_error( pid, sc_num ); ptlib_restore_state( pid, state->saved_state ); if( success ) { if( state->context_state[2]==1 ) { // Need to erase the override from our database struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); stat_override map; if( get_map( key->dev, key->inode, &map ) ) { map.transient=true; set_map( &map ); dlog("%s: " PID_F " inode " INODE_F " in override mapping marked transient\n", __FUNCTION__, pid, key->inode ); } } } else { // The "restore state" command overwrote the error ptlib_set_error( pid, sc_num, error ); dlog("%s: " PID_F " unlinkat failed with error: %s\n", __FUNCTION__, pid, strerror(error)); } } break; } } return true; } #endif // HAVE_OPENAT bool sys_rename( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_param( pid, state, 1, false, false, 0 ); chroot_translate_param( pid, state, 2, false, false, PATH_MAX ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } #if HAVE_OPENAT bool sys_renameat( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1), 2, false, false, 0 ); chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 3), 4, false, false, PATH_MAX ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } #endif bool sys_rmdir( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); chroot_translate_param( pid, state, 1, false ); // Keep a copy of the directory name to erase state->context_state[0]=0; // Internal state state->context_state[1]=ptlib_get_argument( pid, 1 ); // We need to stat the directory before we erase it ptlib_set_argument( pid, 2, state->mem->get_mem() ); ptlib_set_syscall( pid, PREF_LSTAT ); state->state=pid_state::REDIRECT2; } else if( state->state==pid_state::REDIRECT2 ) { if( state->context_state[0]==0 ) { // lstat returned if( ptlib_success( pid, sc_num ) ) { ptlib_stat stat; if( !ptlib_get_mem( pid, state->mem->get_mem(), &stat, sizeof( stat ) ) ) { // This should never happen. We passed a buffer we are in charge of! assert(0); } struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); key->dev=stat.dev; key->inode=stat.ino; state->context_state[0]=1; // Run the original syscall ptlib_save_state( pid, state->saved_state ); ptlib_generate_syscall( pid, state->orig_sc, state->mem->get_shared() ); state->state=pid_state::REDIRECT1; } else { // Pass the lstat error as if it were the rmdir error state->state=pid_state::NONE; } } else if( state->context_state[0]==1 ) { bool success=ptlib_success( pid, sc_num ); int error=success?0:ptlib_get_error( pid, sc_num ); ptlib_restore_state( pid, state->saved_state ); if( success ) { // Need to erase the override from our database struct override_key *key=reinterpret_cast(state->mem->get_loc_c()+PATH_MAX); stat_override map; if( get_map( key->dev, key->inode, &map ) ) { map.transient=true; set_map( &map ); dlog("sys_rmdir: " PID_F " inode " INODE_F " in override mapping marked transient\n", pid, key->inode ); } } else { // Need to copy the error number (overwritten by the state restore) ptlib_set_error( pid, sc_num, error ); } state->state=pid_state::NONE; } } return true; } #if HAVE_OPENAT bool sys_generic_chroot_at( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, true ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } bool sys_generic_chroot_link_at( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, false ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } // Generic chroot where follow or no follow is determined by AT_SYMLINK_NOFOLLOW in parameter 4 bool sys_generic_chroot_at_link4( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { PROC_MEM_LOCK(); state->state=pid_state::RETURN; chroot_translate_paramat( pid, state, ptlib_get_argument( pid, 1 ), 2, (ptlib_get_argument( pid, 4)&AT_SYMLINK_NOFOLLOW)==0 ); } else if( state->state==pid_state::RETURN ) { state->state=pid_state::NONE; } return true; } #endif // HAVE_OPENAT fakeroot-ng-0.18/README.packaging0000644000175000017500000000167612131750746014675 0ustar sunsunBuilding fakeroot-ng is fairly straight forward. Generally, it follows the standard path of configure, make, make install. Packagers are highly advised to use the --with-memdir configure option to direct the temporary files creation to a directory that is guaranteed to be mounted on a ram disk. Fakeroot-ng is perfectly fine installed on the same system as fakeroot. At least on Debian derived systems, fakeroot installs itself through the alternatives system, so you can use it to pick whether to run the sysv or tcp versions. Since the basic command line is the same for fakeroot and fakeroot-ng it is possible to use that system to give the user the option to use fakeroot-ng when running plain "fakeroot". For most cases, that will work as is. Please note that the only platforms supported by fakeroot-ng at the moment are x86_64, i386 and ppc (32 bit only). Further platform support is conditioned on the developer getting access to such a platform. fakeroot-ng-0.18/parent.cpp0000644000175000017500000012260012130614054014044 0ustar sunsun/* Fakeroot Next Generation - run command with fake root privileges This program is copyrighted. Copyright information is available at the AUTHORS file at the root of the source tree for the fakeroot-ng project 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include #include #include #include #include #include #include #include #include "arch/platform.h" #include "parent.h" #include "syscalls.h" #include "process.h" #include "daemon.h" // forward declaration of function static bool handle_memory_allocation( int sc_num, pid_t pid, pid_state *state ); // Keep track of handled syscalls static std::unordered_map syscalls; // Keep track of the states for the various processes template class map_class : public std::unordered_map { // Inherit everything, just disable the dangerous operator[] public: data &operator[] (const key &k) { return std::unordered_map::operator[] (k); } const data &operator[] ( const key &k) const { return std::unordered_map::operator[] (k); } }; static map_class state; size_t static_mem_size, shared_mem_size; static std::unordered_map root_children; // Map of all root children static int num_processes; // Number of running processes // Definitions of some methods pid_state::process_memory::~process_memory() { if( shared_mem_local!=MAP_FAILED ) { if( munmap( (void*)(((int_ptr)shared_mem_local)-shared_overhead), shared_size )<0 ) { // Log the error, but do not otherwise do anything interesting ... dlog("~process_memory: munmap( %p, %lu ) failed with %s\n", (void*)(((int_ptr)shared_mem_local)-shared_overhead), (unsigned long)shared_size, strerror(errno) ); // ... unless we're in debug mode :-) dlog(NULL); assert(false); } shared_mem_local=MAP_FAILED; } } static void init_handlers() { // A macro for defining a system call with different syscall and handler names #define DEF_SYS2( syscall, function ) syscalls[SYS_##syscall]=syscall_hook(sys_##function, #syscall) // A macro fro defining a system call with the same syscall and handler names #define DEF_SYS1( syscall ) DEF_SYS2( syscall, syscall ) DEF_SYS1(geteuid); #if defined(SYS_geteuid32) DEF_SYS2(geteuid32, geteuid); #endif DEF_SYS1(getuid); #if defined(SYS_getuid32) DEF_SYS2(getuid32, getuid); #endif DEF_SYS1(getegid); #if defined(SYS_getegid32) DEF_SYS2(getegid32, getegid); #endif DEF_SYS1(getgid); #if defined(SYS_getgid32) DEF_SYS2(getgid32, getgid); #endif DEF_SYS1(getresuid); #if defined(SYS_getresuid32) DEF_SYS2(getresuid32, getresuid); #endif DEF_SYS1(getresgid); #if defined(SYS_getresgid32) DEF_SYS2(getresgid32, getresgid); #endif DEF_SYS1(getgroups); #if defined(SYS_getgroups32) DEF_SYS2(getgroups32, getgroups); #endif DEF_SYS1(setuid); #ifdef SYS_seteuid DEF_SYS1(seteuid); #endif #ifdef SYS_seteuid32 DEF_SYS2(seteuid32, seteuid); #endif #ifdef SYS_setfsuid DEF_SYS1(setfsuid); #endif #ifdef SYS_setfsuid32 DEF_SYS2(setfsuid32, setfsuid); #endif #ifdef SYS_setresuid DEF_SYS1(setresuid); #endif #ifdef SYS_setresuid32 DEF_SYS2(setresuid32, setresuid); #endif DEF_SYS1(setreuid); #ifdef SYS_setreuid32 DEF_SYS2(setreuid32, setreuid); #endif DEF_SYS1(setgid); #ifdef SYS_setegid DEF_SYS1(setegid); #endif #ifdef SYS_setegid32 DEF_SYS2(setegid32, setegid); #endif #ifdef SYS_setfsgid DEF_SYS1(setfsgid); #endif #ifdef SYS_setfsgid32 DEF_SYS2(setfsgid32, setfsgid); #endif #ifdef SYS_setresgid DEF_SYS1(setresgid); #endif #ifdef SYS_setresgid32 DEF_SYS2(setresgid32, setresgid); #endif DEF_SYS1(setregid); #ifdef SYS_setregid32 DEF_SYS2(setregid32, setregid); #endif DEF_SYS1(setgroups); #if defined(SYS_setgroups32) DEF_SYS2(setgroups32, setgroups); #endif DEF_SYS1(fork); DEF_SYS1(vfork); #if defined(SYS_clone) DEF_SYS1(clone); #endif // Execve is special cased // DEF_SYS1(execve); #if defined(SYS_sigreturn) DEF_SYS1(sigreturn); #endif #if defined(SYS_rt_sigreturn) DEF_SYS2(rt_sigreturn, sigreturn); #endif DEF_SYS1(setsid); #if defined(SYS_wait4) DEF_SYS1(wait4); #endif #if defined(SYS_waitpid) DEF_SYS1(waitpid); #endif DEF_SYS1(ptrace); DEF_SYS1(kill); DEF_SYS1(stat); #ifdef SYS_stat64 DEF_SYS2(stat64, stat); #endif DEF_SYS2(fstat, stat); #ifdef SYS_fstat64 DEF_SYS2(fstat64, stat); #endif DEF_SYS2(lstat, stat); #ifdef SYS_lstat64 DEF_SYS2(lstat64, stat); #endif #if defined(SYS_newfstatat) && HAVE_OPENAT DEF_SYS2(newfstatat, fstatat64); #endif #if defined(SYS_fstatat64) && HAVE_OPENAT DEF_SYS1(fstatat64); #endif DEF_SYS1(chown); #if defined(SYS_chown32) DEF_SYS2(chown32, chown); #endif DEF_SYS1(fchown); #if defined(SYS_fchown32) DEF_SYS2(fchown32, fchown); #endif DEF_SYS1(lchown); #if defined(SYS_lchown32) DEF_SYS2(lchown32, lchown); #endif #if defined(SYS_fchownat) && HAVE_OPENAT DEF_SYS1(fchownat); #endif DEF_SYS1(chmod); DEF_SYS1(fchmod); #if defined(SYS_fchmodat) && HAVE_OPENAT DEF_SYS1(fchmodat); #endif DEF_SYS1(mknod); #if defined(SYS_mknodat) && HAVE_OPENAT DEF_SYS1(mknodat); #endif DEF_SYS1(open); #if defined(SYS_openat) && HAVE_OPENAT DEF_SYS1(openat); #endif DEF_SYS1(mkdir); #if defined(SYS_mkdirat) && HAVE_OPENAT DEF_SYS1(mkdirat); #endif DEF_SYS1(symlink); #if defined(SYS_mkdirat) && HAVE_OPENAT DEF_SYS1(symlinkat); #endif DEF_SYS1(link); #if defined(SYS_linkat) && HAVE_OPENAT DEF_SYS1(linkat); #endif DEF_SYS1(unlink); #if defined(SYS_unlinkat) && HAVE_OPENAT DEF_SYS1(unlinkat); #endif DEF_SYS1(rename); #if defined(SYS_renameat) && HAVE_OPENAT DEF_SYS1(renameat); #endif DEF_SYS1(rmdir); DEF_SYS2(readlink, generic_chroot_support_link_param1); #if defined(SYS_renameat) && HAVE_OPENAT DEF_SYS2(readlinkat, generic_chroot_link_at); #endif DEF_SYS2(truncate, generic_chroot_support_param1); #ifdef SYS_truncate64 DEF_SYS2(truncate64, generic_chroot_support_param1); #endif DEF_SYS2(statfs, generic_chroot_support_param1); // XXX Should last link be resolved? #ifdef SYS_statfs64 DEF_SYS2(statfs64, generic_chroot_support_param1); // XXX Should last link be resolved? #endif DEF_SYS2(chdir, generic_chroot_support_param1); DEF_SYS2(access, generic_chroot_support_param1); #if defined(SYS_faccessat) && HAVE_OPENAT DEF_SYS2(faccessat, generic_chroot_at_link4); #endif DEF_SYS2(utime, generic_chroot_support_param1); DEF_SYS2(utimes, generic_chroot_support_param1); #ifdef SYS_setxattr DEF_SYS2(setxattr, generic_chroot_support_param1); DEF_SYS2(getxattr, generic_chroot_support_param1); DEF_SYS2(listxattr, generic_chroot_support_param1); DEF_SYS2(removexattr, generic_chroot_support_param1); #endif #ifdef SYS_lsetxattr DEF_SYS2(lsetxattr, generic_chroot_support_link_param1); DEF_SYS2(lgetxattr, generic_chroot_support_link_param1); DEF_SYS2(llistxattr, generic_chroot_support_link_param1); DEF_SYS2(lremovexattr, generic_chroot_support_link_param1); #endif #ifdef SYS_uselib DEF_SYS2(uselib, generic_chroot_support_param1); #endif #ifdef SYS_inotify_add_watch DEF_SYS2(inotify_add_watch, generic_chroot_support_param1); #endif #if defined(SYS_futimesat) && HAVE_OPENAT DEF_SYS2(futimesat, generic_chroot_at); #endif #if defined(SYS_utimensat) && HAVE_OPENAT DEF_SYS2(utimensat, generic_chroot_at_link4); #endif DEF_SYS1(chroot); DEF_SYS1(getcwd); DEF_SYS1(mmap); #ifdef SYS_mmap2 DEF_SYS2(mmap2, mmap); #endif DEF_SYS1(munmap); } void init_globals() { size_t page_size=sysconf(_SC_PAGESIZE); static_mem_size=page_size; shared_mem_size=2*PATH_MAX+ptlib_prepare_memory_len(); // Round this to the higher page size shared_mem_size+=page_size-1; shared_mem_size-=shared_mem_size%page_size; } // Debug related functions static const char *sig2str( int signum ) { static char buffer[64]; switch(signum) { #define SIGNAME(a) case a: return #a; SIGNAME(SIGHUP); SIGNAME(SIGINT); SIGNAME(SIGQUIT); SIGNAME(SIGILL); SIGNAME(SIGTRAP); SIGNAME(SIGABRT); SIGNAME(SIGBUS); SIGNAME(SIGFPE); SIGNAME(SIGKILL); SIGNAME(SIGSEGV); SIGNAME(SIGPIPE); SIGNAME(SIGALRM); SIGNAME(SIGTERM); SIGNAME(SIGCHLD); SIGNAME(SIGCONT); SIGNAME(SIGSTOP); #undef SIGNAME default: sprintf(buffer, "signal %d", signum); } return buffer; } static const char *state2str( pid_state::states state ) { static char buffer[64]; switch(state) { #define STATENAME(a) case pid_state::a: return #a; STATENAME(INIT) STATENAME(NONE) STATENAME(RETURN) STATENAME(REDIRECT1) STATENAME(REDIRECT2) STATENAME(REDIRECT3) STATENAME(ALLOCATE) STATENAME(ALLOC_RETURN) STATENAME(WAITING) STATENAME(ZOMBIE) #undef STATENAME } sprintf(buffer, "Unknown state %d", state); return buffer; } void dump_registers( pid_t pid ) { if( log_level>0 ) { void *state[PTLIB_STATE_SIZE]; ptlib_save_state( pid, state ); for( unsigned int i=0; iwaiting_signals.push_back( waiting ); // Is the parent currently waiting? if( proc_state->state==pid_state::WAITING ) { // Call the original function handler, now that it has something to do if( syscalls[proc_state->orig_sc].func( -1, parent, proc_state ) ) { dlog("notify_parent: " PID_F " released from wait\n", parent); ptlib_continue(PTRACE_SYSCALL, parent, 0); } } } static void handle_exit( pid_t pid, int status, const struct rusage &usage ) { // Let's see if the process doing the exiting is even registered pid_state *proc_state=lookup_state(pid); dlog(NULL); assert(proc_state!=NULL); // Set the process state to ZOMBIE with usage count of 1 proc_state->state=pid_state::ZOMBIE; proc_state->context_state[0]=1; dlog("%s: " PID_F " is now a zombie\n", __func__, pid ); pid_state *parent_state=lookup_state(proc_state->parent); // Notify the parent #if PTLIB_PARENT_CAN_WAIT // If a parent can wait on a debugged child we need to notify it even if the child is being debugged, // but only if it actually has a parent (i.e. - was not reparented to init) // Of course, if the debugger IS the parent, there is no need to notify it twice if( proc_state->parent!=0 && proc_state->parent!=1 ) #else // If a parent cannot wait, we need to let it know ourselves only if it's not being debugged if( (proc_state->debugger==0 || proc_state->debugger==proc_state->parent) && proc_state->parent!=0 && proc_state->parent!=1 ) #endif { proc_state->context_state[0]++; // Update use count notify_parent( proc_state->parent, pid_state::wait_state( pid, status, &usage, false ) ); } // Regardless of whether it is being notified or not, the parent's child num needs to be decreased if( parent_state!=NULL ) { parent_state->num_children--; } if( proc_state->debugger!=0 && proc_state->debugger!=proc_state->parent ) { // The process was being debugged - notify the debugger as well proc_state->context_state[0]++; // Update use count notify_parent( proc_state->parent, pid_state::wait_state( pid, status, &usage, true ) ); state[proc_state->debugger].num_debugees--; } // Is any process a child of this process? // We need to delete all child zombie processes. This means changing the list while scanning it. // Instead, create a list of pids to delete std::set need_delete; for( std::unordered_map::iterator i=state.begin(); i!=state.end(); ++i ) { if( i->second.parent==pid ) { dlog("Reparenting process %d to init from %d\n", i->first, pid); i->second.parent=1; if( i->second.state==pid_state::ZOMBIE ) { // "init" should release it need_delete.insert(i->first); } } if( i->second.debugger==pid ) { dlog("Detaching process %d from recursive debugger %d\n", i->first, pid ); i->second.debugger=0; if( i->second.state==pid_state::ZOMBIE && i->second.parent!=pid ) { // The process is in zombie state, pid is its debugger but not parent need_delete.insert(i->first); } } } for( std::set::iterator i=need_delete.begin(); i!=need_delete.end(); ++i ) { delete_state(*i); } // Delete the state from our end. The state is reference counted, so it may not actually be deleted just yet delete_state(pid); } void handle_new_process( pid_t parent_id, pid_t child_id ) { // Copy the session information pid_state *child=&state[child_id]; // We actually want to create the state if it did not already exist if( child->state!=pid_state::INIT ) { // Due to platform incompatibilities and other issues, we may be called several times over the same // child. Don't make a fuss - just return. dlog("%s: Process " PID_F " already registered - not performing any operation\n", __FUNCTION__, child_id ); return; } dlog("%s: Registering " PID_F " with parent " PID_F "\n", __FUNCTION__, child_id, parent_id ); // The platform may want to init the process in some way ptlib_prepare(child_id); // If this is a new root process, we do not actually start monitoring it just yet. if( parent_id!=-1 ) child->state=pid_state::NONE; pid_state *parent=lookup_state(parent_id); if( parent!=NULL ) { // If this assert fails, we somehow created a -1 process - not good dlog(NULL); assert(parent_id!=-1); // This process is not a root process - it has a parent // Copy everything from the parent, except what you don't copy *child=*parent; int_ptr process_type=parent->context_state[0]; if( (process_type&NEW_PROCESS_SAME_PARENT)==0 ) child->parent=parent_id; pid_state *child_parent=lookup_state(child->parent); if( child_parent!=NULL ) { child_parent->num_children++; } child->num_children=0; child->num_debugees=0; // Whether the VM was copied or shared, the new process has the same static and shared memory // If the VM is not shared, setting shared_memory but not shared_mem_local is an indication that the // old memory needs to be freed if( (process_type&NEW_PROCESS_SAME_VM)==0 ) { // The processes do not share the same VM child->mem=ref_count(new pid_state::process_memory); child->mem->set_remote_static(parent->mem->get_mem()); /* The remote shared pointer for the parent is also valid for the child, but it is the same memory, not a copy. Keep the "shared_memory" pointer valid, but the "shared_mem_local" will be NULL to signify this is memory we need to munmap. */ child->mem->set_remote_shared( parent->mem->get_shared() ); } if( (process_type&NEW_PROCESS_SAME_DEBUGGER)==0 ) { // The process inherits the debugger from the parent child->debugger=0; child->trace_mode=TRACE_DETACHED; } } else { // This is a root process - no parent. Set it with the real session ID child->session_id=getsid(child_id); child->root=ref_count(new std::string()); } num_processes++; } int process_sigchld( pid_t pid, enum PTLIB_WAIT_RET wait_state, int status, long ret ) { long sig=0; pid_state *proc_state=lookup_state(pid); if( wait_state!=NEWPROCESS && proc_state==NULL ) { // The process does not exist! // Register it pid_t parent_pid=ptlib_get_parent(pid); dlog("Caught unknown new process " PID_F ", detected parent " PID_F "\n", pid, parent_pid ); dlog(NULL); assert( parent_pid==0 || parent_pid==1 || state.find(parent_pid)!=state.end() ); // Make sure the parent is, indeed, ours // Handle the process creation before handling the syscall return process_sigchld( parent_pid, NEWPROCESS, status, pid ); // Handle the rest of the syscall as a return from a syscall wait_state=SYSCALL; proc_state=lookup_state(pid); assert(proc_state!=NULL); ret=proc_state->orig_sc; } switch(wait_state) { case SYSCALL: { bool posttrap_always=false; if( proc_state->state==pid_state::REDIRECT1 ) { // REDIRECT1 is just a filler state between the previous call, where the arguments were set up and // the call initiated, and the call's return (REDIRECT2). No need to actually call the handler dlog(PID_F ": Calling syscall %ld redirected from %s\n", pid, ret, syscalls[proc_state->orig_sc].name ); proc_state->state=pid_state::REDIRECT2; } else if( proc_state->state==pid_state::REDIRECT2 || proc_state->state==pid_state::REDIRECT3 ) { // REDIRECT2 means a return from a syscall generated by us. // REDIRECT3 means entering a syscall generated by us, but for which the handler function would like // to be notified (unlike REDIRECT1 above, which is short circuited) if( proc_state->orig_sc!=SYS_execve ) { dlog(PID_F ": Called syscall %ld, redirected from %s\n", pid, ret, syscalls[proc_state->orig_sc].name ); if( !syscalls[proc_state->orig_sc].func( ret, pid, proc_state ) ) sig=-1; // Mark for ptrace not to continue the process } else { // Special handling of the execve case dlog(PID_F ": Called syscall %ld, redirected from execve\n", pid, ret ); if( !sys_execve( ret, pid, proc_state, posttrap_always ) ) sig=-1; } } else { if( proc_state->state==pid_state::ALLOCATE ) { if( !handle_memory_allocation( ret, pid, proc_state ) ) sig=-1; } if( proc_state->state!=pid_state::ALLOCATE ) { // Sanity check - returning from same syscall that got us in if( proc_state->state==pid_state::RETURN && ret!=proc_state->orig_sc ) { dlog("process " PID_F " orig_sc=%d actual sc=%ld state=%s\n", pid, proc_state->orig_sc, ret, state2str(proc_state->state)); dlog(NULL); assert( proc_state->state!=pid_state::RETURN || ret==proc_state->orig_sc ); } if( proc_state->state==pid_state::NONE && proc_state->debugger!=0 && proc_state->trace_mode==TRACE_SYSCALL ) { dlog(PID_F ": pre-syscall hook called for debugger " PID_F "\n", pid, proc_state->debugger ); // Notify the debugger before the syscall proc_state->context_state[0]=wait_state; proc_state->context_state[1]=status; proc_state->context_state[2]=ret; proc_state->trace_mode=TRACE_STOPPED1; pid_state::wait_state waiting; waiting.pid()=pid; waiting.status()=status; getrusage( RUSAGE_CHILDREN, &waiting.usage() ); // XXX BUG This is the wrong function! waiting.debugonly()=true; notify_parent( proc_state->debugger, waiting ); sig=-1; // We'll halt the program until the "debugger" decides what to do with it } else if( !proc_state->mem->get_loc() && proc_state->state==pid_state::NONE && ret!=SYS_execve && ret!=SYS_exit ) { // We need to allocate memory // No point in allocating memory when we are just entering an execve that will get rid of it if( !allocate_process_mem( pid, proc_state, ret ) ) sig=-1; } else { // No debugger or otherwise we need to go ahead with this syscall if( (proc_state->trace_mode&TRACE_MASK2)==TRACE_STOPPED1 ) { proc_state->trace_mode&=TRACE_MASK1; // The debugger may have changed the system call to execute - we will respect it ret=ptlib_get_syscall( pid ); } if( proc_state->state==pid_state::NONE ) // Store the syscall type here (we are not in override) proc_state->orig_sc=ret; if( syscalls.find(ret)!=syscalls.end() ) { dlog(PID_F ": Called %s(%s)\n", pid, syscalls[ret].name, state2str(proc_state->state)); if( !syscalls[ret].func( ret, pid, proc_state ) ) { sig=-1; // Mark for ptrace not to continue the process } } else if( ret==SYS_execve ) { dlog(PID_F ": Called execve(%s)\n", pid, state2str(proc_state->state)); if( !sys_execve(ret, pid, proc_state, posttrap_always ) ) sig=-1; } else { dlog(PID_F ": Unknown syscall %ld(%s)\n", pid, ret, state2str(proc_state->state)); if( proc_state->state==pid_state::NONE ) { proc_state->state=pid_state::RETURN; } else if( proc_state->state==pid_state::RETURN ) { proc_state->state=pid_state::NONE; } } } } } // Check for post-syscall debugger callback // If the system sends a SIGTRAP after a successful execve, the logic is entirely different if( proc_state->debugger!=0 && ( (proc_state->state==pid_state::NONE && proc_state->trace_mode==TRACE_SYSCALL) || posttrap_always ) ) { dlog(PID_F ": notify debugger " PID_F " about post-syscall hook\n", pid, proc_state->debugger ); proc_state->trace_mode=TRACE_STOPPED2; pid_state::wait_state waiting; waiting.pid()=pid; waiting.status()=status; getrusage( RUSAGE_CHILDREN, &waiting.usage() ); // XXX BUG This is the wrong function! waiting.debugonly()=true; notify_parent( proc_state->debugger, waiting ); sig=-1; // Halt process until "debugger" decides it can keep on going } } break; case SIGNAL: dlog(PID_F ": Signal %s\n", pid, sig2str(ret)); if( proc_state->debugger==0 ) { if( proc_state->state==pid_state::INIT ) { // When a process is being debugged, it appears to receive a SIGSTOP after the PTRACE_ATTACH. We use // that signal to synchronize the states of the debugee and us if( ret==SIGSTOP ) { dlog(PID_F ": initial signal of process\n", pid ); sig=0; proc_state->state=pid_state::NONE; } else { dlog(PID_F ": received unexpected signal while in INIT mode\n", pid); // Deliver the signal and continue the process - the SIGSTOP may yet be coming ptrace( PTRACE_CONT, pid, ret, 0 ); sig=-1; } } else { sig=ret; } } else { // Pass the signal to the debugger pid_state::wait_state waiting; waiting.pid()=pid; waiting.status()=status; getrusage( RUSAGE_CHILDREN, &waiting.usage() ); // XXX BUG this is the wrong function! waiting.debugonly()=true; proc_state->trace_mode=TRACE_STOPPED2; notify_parent( proc_state->debugger, waiting ); sig=-1; } break; case EXIT: case SIGEXIT: { if( wait_state==EXIT ) { dlog(PID_F ": Exit with return code %ld\n", pid, ret); } else { dlog(PID_F ": Exit with %s\n", pid, sig2str(ret)); } struct rusage rusage; getrusage( RUSAGE_CHILDREN, &rusage ); handle_exit(pid, status, rusage ); // If this was a root child, we may need to perform notification of exit status std::unordered_map::iterator root_child=root_children.find(pid); if( root_child!=root_children.end() ) { if( root_child->second!=-1 ) { write( root_child->second, &status, sizeof(status) ); close( root_child->second ); } root_children.erase(root_child); } num_processes--; } break; case NEWPROCESS: { dlog(PID_F ": Created new child process %ld\n", pid, ret); handle_new_process( pid, ret ); } } return sig; } bool attach_debugger( pid_t child ) { dlog(NULL); // Attach a debugger to the child if( ptrace(PTRACE_ATTACH, child, 0, 0)!=0 ) { dlog("Could not start trace of process " PID_F ": %s\n", child, strerror(errno) ); throw errno_exception( "Could not start trace of process" ); } dlog("Debugger successfully attached to process " PID_F "\n", child ); // Child has started, and is debugged // root_children[child]=socket; // Mark this as a root child // XXX Above line disabled pending rewrite of "parent can't wait" code handle_new_process( -1, child ); // No parent - a root process return true; } // Do nothing signal handler for sigchld static void sigchld_handler(int signum) { } // Signify whether an alarm was received while we were waiting static bool alarm_happened=false; static void sigalrm_handler(int signum) { alarm_happened=true; } int process_children( daemonProcess *daemon ) { // Initialize the ptlib library ptlib_init(); init_handlers(); init_globals(); dlog( "Begin the process loop\n" ); // Prepare the signal masks so we do not lose SIGCHLD while we wait struct sigaction action; memset( &action, 0, sizeof( action ) ); action.sa_handler=sigchld_handler; sigemptyset( &action.sa_mask ); action.sa_flags=0; sigaction( SIGCHLD, &action, NULL ); action.sa_handler=sigalrm_handler; sigaction( SIGALRM, &action, NULL ); sigset_t orig_signals, child_signals; sigemptyset( &child_signals ); sigaddset( &child_signals, SIGCHLD ); sigaddset( &child_signals, SIGALRM ); sigprocmask( SIG_BLOCK, &child_signals, &orig_signals ); sigdelset( &orig_signals, SIGCHLD ); sigdelset( &orig_signals, SIGALRM ); bool clientsockets=true; while(num_processes>0 || clientsockets) { int status; pid_t pid; long ret; ptlib_extra_data data; enum PTLIB_WAIT_RET wait_state; if( !ptlib_wait( &pid, &status, &data, true ) ) { if( errno==EAGAIN || (errno==ECHILD && num_processes==0) ) { clientsockets=daemon->handle_request( &orig_signals, num_processes>0 ); // Did an alarm signal arrive? if( alarm_happened ) { alarm_happened=false; dump_states(); } } else if( errno==ECHILD ) { // We should never get here. If we have no more children, we should have known about it already dlog( "BUG - ptlib_wait failed with %s while numchildren is still %d\n", strerror(errno), num_processes ); dlog(NULL); num_processes=0; } else { dlog("ptlib_wait failed %d: %s\n", errno, strerror(errno) ); } continue; } ret=ptlib_parse_wait( pid, status, &wait_state ); long sig=process_sigchld( pid, wait_state, status, ret ); // The show must go on if( sig>=0 ) ptlib_continue(PTRACE_SYSCALL, pid, sig); } return 0; } bool allocate_process_mem( pid_t pid, pid_state *state, int sc_num ) { dlog("allocate_process_mem: " PID_F " running syscall %d needs process memory\n", pid, sc_num ); state->orig_sc=sc_num; // Save the old state ptlib_save_state( pid, state->saved_state ); state->state=pid_state::ALLOCATE; if( state->mem->get_shared()!=0 ) state->context_state[0]=20; // Internal allocation state else state->context_state[0]=0; // Internal allocation state return handle_memory_allocation( sc_num, pid, state ); } static bool allocate_shared_mem( pid_t pid, pid_state *state ) { char filename[PATH_MAX]; const char *tmpdir=getenv("FAKEROOT_TMPDIR"); if( tmpdir==NULL ) tmpdir=getenv("TMPDIR"); if( tmpdir==NULL || strlen(tmpdir)>=PATH_MAX-sizeof("/fakeroot-ng.XXXXXX") ) tmpdir=DEFAULT_TMPDIR; sprintf(filename, "%s/fakeroot-ng.XXXXXX", tmpdir); int fd=mkstemp(filename); if( fd==-1 ) { dlog("allocate_shared_mem: " PID_F " Failed to create file %s: %s\n", pid, filename, strerror(errno) ); // We'll kill the process ptlib_continue( PTRACE_KILL, pid, 0 ); return false; // Freeze the process until the signal arrives } // Make sure that the file is big enough, but create it sparse ftruncate( fd, shared_mem_size ); // Map the file into the local address space char *memory=(char *)mmap( NULL, shared_mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0 ); if( memory==MAP_FAILED ) { dlog("allocate_shared_mem: " PID_F " filed to map file %s into memory: %s\n", pid, filename, strerror(errno) ); // Cleanup close(fd); unlink(filename); ptlib_continue( PTRACE_KILL, pid, 0 ); return false; } // Fill in the memory with necessary commands and adjust the pointer memcpy( memory, ptlib_prepare_memory(), ptlib_prepare_memory_len() ); // We need to remember the name of the temporary file so we can unlink it strcpy(memory+ptlib_prepare_memory_len(), filename); // Cleanup close(fd); // Set the shared memory class to know who we are state->mem->set_local_addr(memory, shared_mem_size, ptlib_prepare_memory_len()); // The local shared memory is mapped. Now we need to map the remote end // Generate a new system call // Copy the instructions for generating a syscall to the newly created memory ptlib_set_mem( pid, ptlib_prepare_memory(), state->mem->get_mem(), ptlib_prepare_memory_len() ); // Fill in the parameters to open the same file ptlib_set_argument( pid, 1, state->mem->get_mem()+ptlib_prepare_memory_len() ); ptlib_set_string( pid, state->mem->get_loc_c(), state->mem->get_mem()+ptlib_prepare_memory_len() ); ptlib_set_argument( pid, 2, O_RDONLY ); return true; } // Table of states: // Start states - if have nothing - 0 // if have static buffer and old shared buffer - 20 // First we define the various stages of the state machine: static bool hma_state0( int sc_num, pid_t pid, pid_state *state ) { // Translate the whatever call into an mmap to allocate the process local memory ptlib_set_syscall( pid, PREF_MMAP ); ptlib_set_argument( pid, 1, 0 ); // start pointer ptlib_set_argument( pid, 2, static_mem_size ); // Length of page(s) ptlib_set_argument( pid, 3, (PROT_EXEC|PROT_READ|PROT_WRITE) ); // Protection - allow execute ptlib_set_argument( pid, 4, (MAP_PRIVATE|MAP_ANONYMOUS) ); // Flags - anonymous memory allocation ptlib_set_argument( pid, 5, -1 ); // File descriptor ptlib_set_argument( pid, 6, 0 ); // Offset return true; } static bool hma_state1( int sc_num, pid_t pid, pid_state *state ) { // First step - mmap just returned if( ptlib_success( pid, sc_num ) ) { state->mem->set_remote_static(ptlib_get_retval( pid )); dlog("handle_memory_allocation: " PID_F " allocated for our use %lu bytes at %p\n", pid, (unsigned long)static_mem_size, (void *)state->mem->get_mem()); // "All" we need now is the shared memory. First, let's generate the local version for it. if(allocate_shared_mem( pid, state )) return ptlib_generate_syscall( pid, SYS_open, state->mem->get_mem()+ptlib_prepare_memory_len() ); else return false; } else { // The allocation failed. What can you do except kill the process? dlog("handle_memory_allocation: " PID_F " our memory allocation failed with error. Kill process. %s\n", pid, strerror(ptlib_get_error(pid, sc_num)) ); ptlib_continue( PTRACE_KILL, pid, 0 ); return false; } } static bool hma_state20( int sc_num, pid_t pid, pid_state *state ) { // Start state for the case where there is already an allocated shared mem // Save the remote pointer to the old memory, so we can free it later state->context_state[2]=state->mem->get_shared(); // Need to reallocate the shared memory if(allocate_shared_mem( pid, state ) ) { return ptlib_set_syscall( pid, SYS_open )==0; } else { return false; } } static bool hma_state3( int sc_num, pid_t pid, pid_state *state ) { // The "open" syscall returned // Whether it failed or succeeded, we no longer need the file unlink( state->mem->get_loc_c() ); if( ptlib_success( pid, sc_num ) ) { // Store the fd for our own future use state->context_state[1]=ptlib_get_retval( pid ); // Perform the mmap ptlib_set_argument( pid, 1, (int_ptr)NULL ); ptlib_set_argument( pid, 2, shared_mem_size ); ptlib_set_argument( pid, 3, PROT_READ|PROT_EXEC ); ptlib_set_argument( pid, 4, MAP_SHARED ); ptlib_set_argument( pid, 5, state->context_state[1] ); ptlib_set_argument( pid, 6, 0 ); ptlib_generate_syscall( pid, PREF_MMAP, state->mem->get_mem()+ptlib_prepare_memory_len() ); } else { // open failed dlog( "handle_memory_allocation: " PID_F " process failed to open %s: %s\n", pid, state->mem->get_loc_c(), strerror(ptlib_get_error(pid, sc_num)) ); ptlib_continue( PTRACE_KILL, pid, 0 ); return false; } return true; } static bool hma_state5( int sc_num, pid_t pid, pid_state *state ) { // mmap call return if( ptlib_success( pid, sc_num ) ) { // mmap succeeded state->mem->set_remote_shared(ptlib_get_retval( pid )+ptlib_prepare_memory_len()); dlog("handle_memory_allocation: " PID_F " allocated for our use %lu shared bytes at %p\n", pid, (unsigned long)shared_mem_size, (void *)(state->mem->get_shared()-ptlib_prepare_memory_len())); // We now need to close the file descriptor ptlib_set_argument( pid, 1, state->context_state[1] ); return ptlib_generate_syscall( pid, SYS_close, state->mem->get_shared() ); } else { dlog( "handle_memory_allocation: " PID_F " process failed to mmap memory: %s\n", pid, strerror(ptlib_get_error(pid, sc_num) ) ); ptlib_continue( PTRACE_KILL, pid, 0 ); return false; } return true; } static bool hma_state7( int sc_num, pid_t pid, pid_state *state ) { // Close done - we can revert to whatever we were previously doing if( !ptlib_success( pid, sc_num ) ) { // If close failed, we'll log the error and leak the file descriptor, but otherwise do nothing about it dlog( "handle_memory_allocation: " PID_F " procss close failed: %s\n", pid, strerror(ptlib_get_error(pid, sc_num) ) ); } return ptlib_generate_syscall( pid, state->orig_sc , state->mem->get_shared() ); } static bool hma_state8( int sc_num, pid_t pid, pid_state *state ) { // The syscall to restart is entering the kernel { ptlib_restore_state( pid, state->saved_state ); state->state=pid_state::NONE; dlog("handle_memory_allocation: " PID_F " restore state and call handler for syscall %d\n", pid, sc_num ); } return true; } static bool hma_state25( int sc_num, pid_t pid, pid_state *state ) { // Close done - we now need to deallocate the previous shared mem if( !ptlib_success( pid, sc_num ) ) { // If close failed, we'll log the error and leak the file descriptor, but otherwise do nothing about it dlog( "handle_memory_allocation: " PID_F " procss close failed: %s\n", pid, strerror(ptlib_get_error(pid, sc_num) ) ); } ptlib_set_argument( pid, 1, state->context_state[2]-ptlib_prepare_memory_len() ); ptlib_set_argument( pid, 2, shared_mem_size ); ptlib_generate_syscall( pid, SYS_munmap, state->mem->get_shared() ); return true; } static bool hma_state27( int sc_num, pid_t pid, pid_state *state ) { // Munmap done if( !ptlib_success( pid, sc_num ) ) { // Again, if the unmap failed, we'll log it but otherwise continue dlog( "handle_memory_allocation: " PID_F " process munmap failed: %s\n", pid, strerror( ptlib_get_error(pid, sc_num) ) ); } // Restart the original system call state->context_state[0]=8; // Merge with the original code return ptlib_generate_syscall( pid, state->orig_sc, state->mem->get_shared() ); } static bool handle_memory_allocation( int sc_num, pid_t pid, pid_state *state ) { bool ret=true; switch( state->context_state[0]++ ) { case 0: ret=hma_state0( sc_num, pid, state ); break; case 1: return hma_state1( sc_num, pid, state ); case 20: return hma_state20( sc_num, pid, state ); case 2: // The entrance to the "open" syscall on the shared file break; case 3: case 21: ret=hma_state3( sc_num, pid, state ); break; case 4: case 22: // The mmap call entry break; case 5: case 23: ret=hma_state5( sc_num, pid, state ); break; case 6: case 24: // Close call entry break; // The first time and repeat allocations diverge again - case 25 is handled further on case 7: return hma_state7( sc_num, pid, state ); case 8: ret=hma_state8( sc_num, pid, state ); break; case 25: ret=hma_state25( sc_num, pid, state ); break; case 26: // Syscall enter for munmap break; case 27: ret=hma_state27( sc_num, pid, state ); break; } return ret; } bool sys_mmap( int sc_num, pid_t pid, pid_state *state ) { if( state->state==pid_state::NONE ) { dlog("mmap: " PID_F " direct call\n", pid); state->state=pid_state::RETURN; } else if( state->state==pid_state::RETURN ) { dlog("mmap: " PID_F " direct return\n", pid); state->state=pid_state::NONE; } return true; } pid_state *lookup_state( pid_t pid ) { std::unordered_map::iterator process=state.find(pid); if( process!=state.end() ) { return &process->second; } return NULL; } void delete_state( pid_t pid ) { pid_state *proc_state=lookup_state(pid); assert(proc_state!=NULL); assert(proc_state->state==pid_state::ZOMBIE); if( (--proc_state->context_state[0])==0 ) state.erase(pid); } void dump_states() { // Print the header dlog("PID\tParent\tState\n"); for( map_class::const_iterator i=state.begin(); i!=state.end(); ++i ) { dlog(PID_F "\t" PID_F "\t%s", i->first, i->second.parent, state2str(i->second.state) ); if( i->second.state==pid_state::ZOMBIE ) { dlog("(%d)", (int)i->second.context_state[0]); } dlog("\n"); } dlog(NULL); } fakeroot-ng-0.18/bootstrap0000755000175000017500000000003312077265762014027 0ustar sunsun#!/bin/sh -e autoreconf -i fakeroot-ng-0.18/ChangeLog0000644000175000017500000001075512131750746013642 0ustar sunsunVersion 0.18 * Fix a problem with fchmodat * Fix a race in case of new client attaching just as the daemon is shutting down. * Rennovate the entire startup sequence. * Resolve the threading problem * Solve crash when run without a persitent state file * Performance changes * Update the home page * Add packaging tips in the README and README.packaging files * Add -h help command line option Version 0.17 * Allow setting the process credentials to things other than root Version 0.16 * Sending an ALRM signal to the fakeroot-ng process dumps to the log all tracked processes, along with their state * Add -f option - flush log after every print * Greater support for platforms that have no automatic new process attach mechanisms. Will now detect children through the clone return code. * Improve the ptrace emulation layer - will now attach fake debugger to child correctly. * Fix to the PTRACE_DETACH emulation - would not restart the process from which we detached. Version 0.15 * mkdirat would not put the directory into the lie database * When running chmod and when creating files and directories - do not allow the user to actually remove the permission for user - emulates the root behavior of allowing access to a file regardless of its actual permission. * Fix bug - when importing existing file's permission into the lie database, we used to copy the file's real uid into the fake gid. Version 0.14 * Fix bug in unlinkat - context data used in incorrect order, resulting in "Not a directory" error when deleting a file. * Remove configure command line to get format string protection to dlog * Solve all dlog format string warnings * Fix bug in distclean - would not remomve generated template makfile from arch/linux directory * The -p option will now connect to an existing debugger, if one exists. * Allow use of FAKEROOT_TMPDIR as well as TMPDIR for setting the location of the temporary files * Allow changing the default shared mem directory from /tmp via a configure command option (--with-memdir) Version 0.13 * Remove libtool from the ptlib build system. Make the actual build faster. Suggested by Bernhard R. Link * Add checks to make sure that fakeroot-ng will warn of a temporary directory that is mounted with "noexec" * Running "fakeroot-ng" with no arguments will run the current shell as "root" Version 0.12 * Complete the chroot support for all *at functions Version 0.11 * Fix compilation error * Resolve uninitialized buffer reliance for fork and vfork Version 0.10 * Implement set_string for copying a string into process space * Prevent the debugged process from sending a signal to the debugger * Chroot support (all but the *at functions) Version 0.09 * Read and writes to process memory can now be performed in any length and/or alignment * As a result - recursive debugger now works for x86_64 (only for 64bit) Version 0.08 * Many many many code cleanups * New platform (partially) supported - Linux/x86_64: * Supported - basic running * Not supported (well) - recursive debuggers, 32 bit programs * Really fix the "openat" issue this time * Add a program "calc_defaults" that attempts to detect values for a new platform's platform_specific.h * Write a new platform porting HOWTO Version 0.07 * Fix compilation errors on platforms that don't or partially support "openat" Version 0.06 * Fix bug with mknod implementation - would save state too late * Fix incorrect use of hyphen as minus in the man page * Add support for fchownat, fchmodat, mknodat, openat, mkdirat, symlinkat Version 0.05 * Add recursive debugger support - mainly strace at the moment Version 0.04 * Add a PowerPC port Version 0.03 * Add storing persistent state between runs * Several bug fixes Version 0.02 * New functions supported: chown, getgid/getegid, mknod (creating device files) * Assume ownership to root when creating files, directories and symbolic links * Improve some "stat" handling semantics * Slight change to the command line parameters * Internal restructuring and code cleanup * Entire emulation of all basic operations (a few know bugs for fringe cases). Version 0.01 * Initial release. Supports Linux/i386 only. Only supports {,f,l}stat64, (f)chmod and get(e)uid.