forked from devuan/eudev
Browse Source
The structure of the source tree is basically correct and this is about as far as we can go without hacking at the C code.master
Anthony G. Basile
11 years ago
16 changed files with 1662 additions and 90 deletions
@ -0,0 +1,339 @@ |
|||
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 Lesser 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. |
|||
|
|||
<one line to give the program's name and a brief idea of what it does.> |
|||
Copyright (C) <year> <name of author> |
|||
|
|||
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. |
|||
|
|||
<signature of Ty Coon>, 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 Lesser General |
|||
Public License instead of this License. |
|||
@ -1,10 +1,2 @@ |
|||
ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS} |
|||
#SUBDIRS = docs keymaps keymaps-force-release man rules src test
|
|||
|
|||
SUBDIRS = keymaps keymaps-force-release |
|||
|
|||
if ENABLE_GTK_DOC |
|||
SUBDIRS += \
|
|||
docs/libudev |
|||
endif |
|||
|
|||
SUBDIRS = src docs keymaps keymaps-force-release man rules test |
|||
|
|||
@ -1,10 +1,14 @@ |
|||
#!/bin/sh |
|||
|
|||
set -e |
|||
|
|||
if type -p gtkdocize > /dev/null; then |
|||
gtkdocize --docdir docs |
|||
gtkdocargs=--enable-gtk-doc |
|||
fi |
|||
|
|||
aclocal && \ |
|||
autoheader && \ |
|||
autoconf && \ |
|||
libtoolize --copy && \ |
|||
gtkdocize --docdir docs && \ |
|||
automake --add-missing --copy |
|||
|
|||
@ -1,60 +0,0 @@ |
|||
# This file is part of systemd. |
|||
# |
|||
# systemd is free software; you can redistribute it and/or modify it |
|||
# under the terms of the GNU Lesser General Public License as published by |
|||
# the Free Software Foundation; either version 2.1 of the License, or |
|||
# (at your option) any later version. |
|||
|
|||
ACTION=="remove", GOTO="systemd_end" |
|||
|
|||
SUBSYSTEM=="tty", KERNEL=="tty[a-zA-Z]*|hvc*|xvc*|hvsi*", TAG+="systemd" |
|||
|
|||
KERNEL=="vport*", TAG+="systemd" |
|||
|
|||
SUBSYSTEM=="block", KERNEL!="ram*|loop*", TAG+="systemd" |
|||
SUBSYSTEM=="block", KERNEL!="ram*|loop*", ENV{DM_UDEV_DISABLE_OTHER_RULES_FLAG}=="1", ENV{SYSTEMD_READY}="0" |
|||
|
|||
# Ignore encrypted devices with no identified superblock on it, since |
|||
# we are probably still calling mke2fs or mkswap on it. |
|||
SUBSYSTEM=="block", KERNEL!="ram*|loop*", ENV{DM_UUID}=="CRYPT-*", ENV{ID_PART_TABLE_TYPE}=="", ENV{ID_FS_USAGE}=="", ENV{SYSTEMD_READY}="0" |
|||
|
|||
# Ignore raid devices that are not yet assembled and started |
|||
SUBSYSTEM=="block", ENV{DEVTYPE}=="disk", KERNEL=="md*", TEST!="md/array_state", ENV{SYSTEMD_READY}="0" |
|||
SUBSYSTEM=="block", ENV{DEVTYPE}=="disk", KERNEL=="md*", ATTR{md/array_state}=="|clear|inactive", ENV{SYSTEMD_READY}="0" |
|||
|
|||
# Ignore nbd devices in the "add" event, with "change" the nbd is ready |
|||
ACTION=="add", SUBSYSTEM=="block", KERNEL=="nbd*", ENV{SYSTEMD_READY}="0" |
|||
|
|||
# We need a hardware independent way to identify network devices. We |
|||
# use the /sys/subsystem path for this. Current vanilla kernels don't |
|||
# actually support that hierarchy right now, however upcoming kernels |
|||
# will. HAL and udev internally support /sys/subsystem already, hence |
|||
# it should be safe to use this here, too. This is mostly just an |
|||
# identification string for systemd, so whether the path actually is |
|||
# accessible or not does not matter as long as it is unique and in the |
|||
# filesystem namespace. |
|||
# |
|||
# http://cgit.freedesktop.org/systemd/systemd/tree/src/libudev/libudev-enumerate.c#n922 |
|||
|
|||
SUBSYSTEM=="net", KERNEL!="lo", TAG+="systemd", ENV{SYSTEMD_ALIAS}+="/sys/subsystem/net/devices/$name" |
|||
SUBSYSTEM=="bluetooth", TAG+="systemd", ENV{SYSTEMD_ALIAS}+="/sys/subsystem/bluetooth/devices/%k" |
|||
|
|||
SUBSYSTEM=="bluetooth", TAG+="systemd", ENV{SYSTEMD_WANTS}+="bluetooth.target" |
|||
ENV{ID_SMARTCARD_READER}=="*?", TAG+="systemd", ENV{SYSTEMD_WANTS}+="smartcard.target" |
|||
SUBSYSTEM=="sound", KERNEL=="card*", TAG+="systemd", ENV{SYSTEMD_WANTS}+="sound.target" |
|||
|
|||
SUBSYSTEM=="printer", TAG+="systemd", ENV{SYSTEMD_WANTS}+="printer.target" |
|||
SUBSYSTEM=="usb", KERNEL=="lp*", TAG+="systemd", ENV{SYSTEMD_WANTS}+="printer.target" |
|||
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ENV{ID_USB_INTERFACES}=="*:0701??:*", TAG+="systemd", ENV{SYSTEMD_WANTS}+="printer.target" |
|||
|
|||
# Apply sysctl variables to network devices (and only to those) as they appear. |
|||
|
|||
SUBSYSTEM=="net", KERNEL!="lo", RUN+="@rootlibexecdir@/systemd-sysctl --prefix=/proc/sys/net/ipv4/conf/$name --prefix=/proc/sys/net/ipv4/neigh/$name --prefix=/proc/sys/net/ipv6/conf/$name --prefix=/proc/sys/net/ipv6/neigh/$name" |
|||
|
|||
# Asynchronously mount file systems implemented by these modules as |
|||
# soon as they are loaded. |
|||
|
|||
SUBSYSTEM=="module", KERNEL=="fuse", ACTION=="add", TAG+="systemd", ENV{SYSTEMD_WANTS}+="sys-fs-fuse-connections.mount" |
|||
SUBSYSTEM=="module", KERNEL=="configfs", ACTION=="add", TAG+="systemd", ENV{SYSTEMD_WANTS}+="sys-kernel-config.mount" |
|||
|
|||
LABEL="systemd_end" |
|||
@ -0,0 +1,139 @@ |
|||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
|||
|
|||
#pragma once |
|||
|
|||
/***
|
|||
This file is part of systemd. |
|||
|
|||
Copyright 2010 Lennart Poettering |
|||
|
|||
systemd is free software; you can redistribute it and/or modify it |
|||
under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation; either version 2.1 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
systemd 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|||
***/ |
|||
|
|||
#include <syslog.h> |
|||
#include <stdbool.h> |
|||
#include <stdarg.h> |
|||
#include <errno.h> |
|||
|
|||
#include "macro.h" |
|||
|
|||
typedef enum LogTarget{ |
|||
LOG_TARGET_CONSOLE, |
|||
LOG_TARGET_KMSG, |
|||
LOG_TARGET_JOURNAL, |
|||
LOG_TARGET_JOURNAL_OR_KMSG, |
|||
LOG_TARGET_SYSLOG, |
|||
LOG_TARGET_SYSLOG_OR_KMSG, |
|||
LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG otherwise */ |
|||
LOG_TARGET_SAFE, /* console if stderr is tty, KMSG otherwise */ |
|||
LOG_TARGET_NULL, |
|||
_LOG_TARGET_MAX, |
|||
_LOG_TARGET_INVALID = -1 |
|||
} LogTarget; |
|||
|
|||
void log_set_target(LogTarget target); |
|||
void log_set_max_level(int level); |
|||
void log_set_facility(int facility); |
|||
|
|||
int log_set_target_from_string(const char *e); |
|||
int log_set_max_level_from_string(const char *e); |
|||
|
|||
void log_show_color(bool b); |
|||
void log_show_location(bool b); |
|||
|
|||
int log_show_color_from_string(const char *e); |
|||
int log_show_location_from_string(const char *e); |
|||
|
|||
LogTarget log_get_target(void); |
|||
int log_get_max_level(void); |
|||
|
|||
int log_open(void); |
|||
void log_close(void); |
|||
void log_forget_fds(void); |
|||
|
|||
void log_close_syslog(void); |
|||
void log_close_journal(void); |
|||
void log_close_kmsg(void); |
|||
void log_close_console(void); |
|||
|
|||
void log_parse_environment(void); |
|||
|
|||
int log_meta( |
|||
int level, |
|||
const char*file, |
|||
int line, |
|||
const char *func, |
|||
const char *format, ...) _printf_attr_(5,6); |
|||
|
|||
int log_metav( |
|||
int level, |
|||
const char*file, |
|||
int line, |
|||
const char *func, |
|||
const char *format, |
|||
va_list ap); |
|||
|
|||
int log_struct_internal( |
|||
int level, |
|||
const char *file, |
|||
int line, |
|||
const char *func, |
|||
const char *format, ...) _sentinel_; |
|||
|
|||
int log_oom_internal( |
|||
const char *file, |
|||
int line, |
|||
const char *func); |
|||
|
|||
/* This modifies the buffer passed! */ |
|||
int log_dump_internal( |
|||
int level, |
|||
const char*file, |
|||
int line, |
|||
const char *func, |
|||
char *buffer); |
|||
|
|||
_noreturn_ void log_assert_failed( |
|||
const char *text, |
|||
const char *file, |
|||
int line, |
|||
const char *func); |
|||
|
|||
_noreturn_ void log_assert_failed_unreachable( |
|||
const char *text, |
|||
const char *file, |
|||
int line, |
|||
const char *func); |
|||
|
|||
#define log_full(level, ...) log_meta(level, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
|
|||
#define log_debug(...) log_meta(LOG_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
#define log_info(...) log_meta(LOG_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
#define log_notice(...) log_meta(LOG_NOTICE, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
#define log_warning(...) log_meta(LOG_WARNING, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
#define log_error(...) log_meta(LOG_ERR, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
|
|||
#define log_struct(level, ...) log_struct_internal(level, __FILE__, __LINE__, __func__, __VA_ARGS__) |
|||
|
|||
#define log_oom() log_oom_internal(__FILE__, __LINE__, __func__) |
|||
|
|||
/* This modifies the buffer passed! */ |
|||
#define log_dump(level, buffer) log_dump_internal(level, __FILE__, __LINE__, __func__, buffer) |
|||
|
|||
bool log_on_console(void); |
|||
|
|||
const char *log_target_to_string(LogTarget target); |
|||
LogTarget log_target_from_string(const char *s); |
|||
|
|||
#define MESSAGE_ID(x) "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(x) |
|||
@ -0,0 +1,242 @@ |
|||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
|||
|
|||
#pragma once |
|||
|
|||
/***
|
|||
This file is part of systemd. |
|||
|
|||
Copyright 2010 Lennart Poettering |
|||
|
|||
systemd is free software; you can redistribute it and/or modify it |
|||
under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation; either version 2.1 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
systemd 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|||
***/ |
|||
|
|||
#include <assert.h> |
|||
#include <sys/param.h> |
|||
#include <sys/types.h> |
|||
#include <sys/uio.h> |
|||
#include <inttypes.h> |
|||
|
|||
#define _printf_attr_(a,b) __attribute__ ((format (printf, a, b))) |
|||
#define _sentinel_ __attribute__ ((sentinel)) |
|||
#define _noreturn_ __attribute__((noreturn)) |
|||
#define _unused_ __attribute__ ((unused)) |
|||
#define _destructor_ __attribute__ ((destructor)) |
|||
#define _pure_ __attribute__ ((pure)) |
|||
#define _const_ __attribute__ ((const)) |
|||
#define _deprecated_ __attribute__ ((deprecated)) |
|||
#define _packed_ __attribute__ ((packed)) |
|||
#define _malloc_ __attribute__ ((malloc)) |
|||
#define _weak_ __attribute__ ((weak)) |
|||
#define _likely_(x) (__builtin_expect(!!(x),1)) |
|||
#define _unlikely_(x) (__builtin_expect(!!(x),0)) |
|||
#define _public_ __attribute__ ((visibility("default"))) |
|||
#define _hidden_ __attribute__ ((visibility("hidden"))) |
|||
#define _weakref_(x) __attribute__((weakref(#x))) |
|||
#define _introspect_(x) __attribute__((section("introspect." x))) |
|||
#define _alignas_(x) __attribute__((aligned(__alignof(x)))) |
|||
|
|||
#define XSTRINGIFY(x) #x |
|||
#define STRINGIFY(x) XSTRINGIFY(x) |
|||
|
|||
/* Rounds up */ |
|||
#define ALIGN(l) ALIGN_TO((l), sizeof(void*)) |
|||
static inline size_t ALIGN_TO(size_t l, size_t ali) { |
|||
return ((l + ali - 1) & ~(ali - 1)); |
|||
} |
|||
|
|||
#define ELEMENTSOF(x) (sizeof(x)/sizeof((x)[0])) |
|||
|
|||
/*
|
|||
* container_of - cast a member of a structure out to the containing structure |
|||
* @ptr: the pointer to the member. |
|||
* @type: the type of the container struct this is embedded in. |
|||
* @member: the name of the member within the struct. |
|||
* |
|||
*/ |
|||
#define container_of(ptr, type, member) ({ \ |
|||
const typeof( ((type *)0)->member ) *__mptr = (ptr); \ |
|||
(type *)( (char *)__mptr - offsetof(type,member) );}) |
|||
|
|||
#ifndef MAX |
|||
#define MAX(a,b) \ |
|||
__extension__ ({ \ |
|||
typeof(a) _a = (a); \ |
|||
typeof(b) _b = (b); \ |
|||
_a > _b ? _a : _b; \ |
|||
}) |
|||
#endif |
|||
|
|||
#define MAX3(a,b,c) \ |
|||
MAX(MAX(a,b),c) |
|||
|
|||
#ifndef MIN |
|||
#define MIN(a,b) \ |
|||
__extension__ ({ \ |
|||
typeof(a) _a = (a); \ |
|||
typeof(b) _b = (b); \ |
|||
_a < _b ? _a : _b; \ |
|||
}) |
|||
#endif |
|||
|
|||
#define MIN3(a,b,c) \ |
|||
MIN(MIN(a,b),c) |
|||
|
|||
#define CLAMP(x, low, high) \ |
|||
__extension__ ({ \ |
|||
typeof(x) _x = (x); \ |
|||
typeof(low) _low = (low); \ |
|||
typeof(high) _high = (high); \ |
|||
((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \ |
|||
}) |
|||
|
|||
#define assert_se(expr) \ |
|||
do { \ |
|||
if (_unlikely_(!(expr))) \ |
|||
log_assert_failed(#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__); \ |
|||
} while (false) \ |
|||
|
|||
/* We override the glibc assert() here. */ |
|||
#undef assert |
|||
#ifdef NDEBUG |
|||
#define assert(expr) do {} while(false) |
|||
#else |
|||
#define assert(expr) assert_se(expr) |
|||
#endif |
|||
|
|||
#define assert_not_reached(t) \ |
|||
do { \ |
|||
log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \ |
|||
} while (false) |
|||
|
|||
#define assert_cc(expr) \ |
|||
do { \ |
|||
switch (0) { \ |
|||
case 0: \ |
|||
case !!(expr): \ |
|||
; \ |
|||
} \ |
|||
} while (false) |
|||
|
|||
#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p))) |
|||
#define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u))) |
|||
|
|||
#define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p))) |
|||
#define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u))) |
|||
|
|||
#define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p))) |
|||
#define ULONG_TO_PTR(u) ((void*) ((uintptr_t) (u))) |
|||
|
|||
#define PTR_TO_INT(p) ((int) ((intptr_t) (p))) |
|||
#define INT_TO_PTR(u) ((void*) ((intptr_t) (u))) |
|||
|
|||
#define TO_INT32(p) ((int32_t) ((intptr_t) (p))) |
|||
#define INT32_TO_PTR(u) ((void*) ((intptr_t) (u))) |
|||
|
|||
#define PTR_TO_LONG(p) ((long) ((intptr_t) (p))) |
|||
#define LONG_TO_PTR(u) ((void*) ((intptr_t) (u))) |
|||
|
|||
#define memzero(x,l) (memset((x), 0, (l))) |
|||
#define zero(x) (memzero(&(x), sizeof(x))) |
|||
|
|||
#define char_array_0(x) x[sizeof(x)-1] = 0; |
|||
|
|||
#define IOVEC_SET_STRING(i, s) \ |
|||
do { \ |
|||
struct iovec *_i = &(i); \ |
|||
char *_s = (char *)(s); \ |
|||
_i->iov_base = _s; \ |
|||
_i->iov_len = strlen(_s); \ |
|||
} while(false) |
|||
|
|||
static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) { |
|||
unsigned j; |
|||
size_t r = 0; |
|||
|
|||
for (j = 0; j < n; j++) |
|||
r += i[j].iov_len; |
|||
|
|||
return r; |
|||
} |
|||
|
|||
static inline size_t IOVEC_INCREMENT(struct iovec *i, unsigned n, size_t k) { |
|||
unsigned j; |
|||
|
|||
for (j = 0; j < n; j++) { |
|||
size_t sub; |
|||
|
|||
if (_unlikely_(k <= 0)) |
|||
break; |
|||
|
|||
sub = MIN(i[j].iov_len, k); |
|||
i[j].iov_len -= sub; |
|||
i[j].iov_base = (uint8_t*) i[j].iov_base + sub; |
|||
k -= sub; |
|||
} |
|||
|
|||
return k; |
|||
} |
|||
|
|||
#define _cleanup_free_ __attribute__((cleanup(freep))) |
|||
#define _cleanup_fclose_ __attribute__((cleanup(fclosep))) |
|||
#define _cleanup_close_ __attribute__((cleanup(closep))) |
|||
#define _cleanup_closedir_ __attribute__((cleanup(closedirp))) |
|||
#define _cleanup_umask_ __attribute__((cleanup(umaskp))) |
|||
#define _cleanup_strv_free_ __attribute__((cleanup(strv_freep))) |
|||
|
|||
#define VA_FORMAT_ADVANCE(format, ap) \ |
|||
do { \ |
|||
int _argtypes[128]; \ |
|||
size_t _i, _k; \ |
|||
_k = parse_printf_format((format), ELEMENTSOF(_argtypes), _argtypes); \ |
|||
assert(_k < ELEMENTSOF(_argtypes)); \ |
|||
for (_i = 0; _i < _k; _i++) { \ |
|||
if (_argtypes[_i] & PA_FLAG_PTR) { \ |
|||
(void) va_arg(ap, void*); \ |
|||
continue; \ |
|||
} \ |
|||
\ |
|||
switch (_argtypes[_i]) { \ |
|||
case PA_INT: \ |
|||
case PA_INT|PA_FLAG_SHORT: \ |
|||
case PA_CHAR: \ |
|||
(void) va_arg(ap, int); \ |
|||
break; \ |
|||
case PA_INT|PA_FLAG_LONG: \ |
|||
(void) va_arg(ap, long int); \ |
|||
break; \ |
|||
case PA_INT|PA_FLAG_LONG_LONG: \ |
|||
(void) va_arg(ap, long long int); \ |
|||
break; \ |
|||
case PA_WCHAR: \ |
|||
(void) va_arg(ap, wchar_t); \ |
|||
break; \ |
|||
case PA_WSTRING: \ |
|||
case PA_STRING: \ |
|||
case PA_POINTER: \ |
|||
(void) va_arg(ap, void*); \ |
|||
break; \ |
|||
case PA_FLOAT: \ |
|||
case PA_DOUBLE: \ |
|||
(void) va_arg(ap, double); \ |
|||
break; \ |
|||
case PA_DOUBLE|PA_FLAG_LONG_DOUBLE: \ |
|||
(void) va_arg(ap, long double); \ |
|||
break; \ |
|||
default: \ |
|||
assert_not_reached("Unknown format string argument."); \ |
|||
} \ |
|||
} \ |
|||
} while(false) |
|||
|
|||
#include "log.h" |
|||
@ -0,0 +1,255 @@ |
|||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
|||
|
|||
#pragma once |
|||
|
|||
/***
|
|||
This file is part of systemd. |
|||
|
|||
Copyright 2010 Lennart Poettering |
|||
|
|||
systemd is free software; you can redistribute it and/or modify it |
|||
under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation; either version 2.1 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
systemd 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|||
***/ |
|||
|
|||
/* Missing glibc definitions to access certain kernel APIs */ |
|||
|
|||
#include <sys/resource.h> |
|||
#include <sys/syscall.h> |
|||
#include <fcntl.h> |
|||
#include <stdlib.h> |
|||
#include <unistd.h> |
|||
#include <linux/oom.h> |
|||
|
|||
#ifdef HAVE_AUDIT |
|||
#include <libaudit.h> |
|||
#endif |
|||
|
|||
#include "macro.h" |
|||
|
|||
#ifdef ARCH_MIPS |
|||
#include <asm/sgidefs.h> |
|||
#endif |
|||
|
|||
#ifndef RLIMIT_RTTIME |
|||
#define RLIMIT_RTTIME 15 |
|||
#endif |
|||
|
|||
#ifndef F_LINUX_SPECIFIC_BASE |
|||
#define F_LINUX_SPECIFIC_BASE 1024 |
|||
#endif |
|||
|
|||
#ifndef F_SETPIPE_SZ |
|||
#define F_SETPIPE_SZ (F_LINUX_SPECIFIC_BASE + 7) |
|||
#endif |
|||
|
|||
#ifndef F_GETPIPE_SZ |
|||
#define F_GETPIPE_SZ (F_LINUX_SPECIFIC_BASE + 8) |
|||
#endif |
|||
|
|||
#ifndef IP_FREEBIND |
|||
#define IP_FREEBIND 15 |
|||
#endif |
|||
|
|||
#ifndef OOM_SCORE_ADJ_MIN |
|||
#define OOM_SCORE_ADJ_MIN (-1000) |
|||
#endif |
|||
|
|||
#ifndef OOM_SCORE_ADJ_MAX |
|||
#define OOM_SCORE_ADJ_MAX 1000 |
|||
#endif |
|||
|
|||
#ifndef AUDIT_SERVICE_START |
|||
#define AUDIT_SERVICE_START 1130 /* Service (daemon) start */ |
|||
#endif |
|||
|
|||
#ifndef AUDIT_SERVICE_STOP |
|||
#define AUDIT_SERVICE_STOP 1131 /* Service (daemon) stop */ |
|||
#endif |
|||
|
|||
#ifndef TIOCVHANGUP |
|||
#define TIOCVHANGUP 0x5437 |
|||
#endif |
|||
|
|||
#ifndef IP_TRANSPARENT |
|||
#define IP_TRANSPARENT 19 |
|||
#endif |
|||
|
|||
#if !HAVE_DECL_PIVOT_ROOT |
|||
static inline int pivot_root(const char *new_root, const char *put_old) { |
|||
return syscall(SYS_pivot_root, new_root, put_old); |
|||
} |
|||
#endif |
|||
|
|||
#ifdef __x86_64__ |
|||
# ifndef __NR_fanotify_init |
|||
# define __NR_fanotify_init 300 |
|||
# endif |
|||
# ifndef __NR_fanotify_mark |
|||
# define __NR_fanotify_mark 301 |
|||
# endif |
|||
#elif defined _MIPS_SIM |
|||
# if _MIPS_SIM == _MIPS_SIM_ABI32 |
|||
# ifndef __NR_fanotify_init |
|||
# define __NR_fanotify_init 4336 |
|||
# endif |
|||
# ifndef __NR_fanotify_mark |
|||
# define __NR_fanotify_mark 4337 |
|||
# endif |
|||
# elif _MIPS_SIM == _MIPS_SIM_NABI32 |
|||
# ifndef __NR_fanotify_init |
|||
# define __NR_fanotify_init 6300 |
|||
# endif |
|||
# ifndef __NR_fanotify_mark |
|||
# define __NR_fanotify_mark 6301 |
|||
# endif |
|||
# elif _MIPS_SIM == _MIPS_SIM_ABI64 |
|||
# ifndef __NR_fanotify_init |
|||
# define __NR_fanotify_init 5295 |
|||
# endif |
|||
# ifndef __NR_fanotify_mark |
|||
# define __NR_fanotify_mark 5296 |
|||
# endif |
|||
# endif |
|||
#else |
|||
# ifndef __NR_fanotify_init |
|||
# define __NR_fanotify_init 338 |
|||
# endif |
|||
# ifndef __NR_fanotify_mark |
|||
# define __NR_fanotify_mark 339 |
|||
# endif |
|||
#endif |
|||
|
|||
#ifndef HAVE_FANOTIFY_INIT |
|||
static inline int fanotify_init(unsigned int flags, unsigned int event_f_flags) { |
|||
return syscall(__NR_fanotify_init, flags, event_f_flags); |
|||
} |
|||
#endif |
|||
|
|||
#ifndef HAVE_FANOTIFY_MARK |
|||
static inline int fanotify_mark(int fanotify_fd, unsigned int flags, uint64_t mask, |
|||
int dfd, const char *pathname) { |
|||
#if defined _MIPS_SIM && _MIPS_SIM == _MIPS_SIM_ABI32 || defined __powerpc__ && !defined __powerpc64__ |
|||
union { |
|||
uint64_t _64; |
|||
uint32_t _32[2]; |
|||
} _mask; |
|||
_mask._64 = mask; |
|||
|
|||
return syscall(__NR_fanotify_mark, fanotify_fd, flags, |
|||
_mask._32[0], _mask._32[1], dfd, pathname); |
|||
#else |
|||
return syscall(__NR_fanotify_mark, fanotify_fd, flags, mask, dfd, pathname); |
|||
#endif |
|||
} |
|||
#endif |
|||
|
|||
#ifndef BTRFS_IOCTL_MAGIC |
|||
#define BTRFS_IOCTL_MAGIC 0x94 |
|||
#endif |
|||
|
|||
#ifndef BTRFS_PATH_NAME_MAX |
|||
#define BTRFS_PATH_NAME_MAX 4087 |
|||
#endif |
|||
|
|||
struct btrfs_ioctl_vol_args { |
|||
int64_t fd; |
|||
char name[BTRFS_PATH_NAME_MAX + 1]; |
|||
}; |
|||
|
|||
#ifndef BTRFS_IOC_DEFRAG |
|||
#define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, struct btrfs_ioctl_vol_args) |
|||
#endif |
|||
|
|||
#ifndef BTRFS_SUPER_MAGIC |
|||
#define BTRFS_SUPER_MAGIC 0x9123683E |
|||
#endif |
|||
|
|||
#ifndef MS_MOVE |
|||
#define MS_MOVE 8192 |
|||
#endif |
|||
|
|||
#ifndef MS_PRIVATE |
|||
#define MS_PRIVATE (1 << 18) |
|||
#endif |
|||
|
|||
#if !HAVE_DECL_GETTID |
|||
static inline pid_t gettid(void) { |
|||
return (pid_t) syscall(SYS_gettid); |
|||
} |
|||
#endif |
|||
|
|||
#ifndef SCM_SECURITY |
|||
#define SCM_SECURITY 0x03 |
|||
#endif |
|||
|
|||
#ifndef MS_STRICTATIME |
|||
#define MS_STRICTATIME (1<<24) |
|||
#endif |
|||
|
|||
#ifndef PR_SET_NO_NEW_PRIVS |
|||
#define PR_SET_NO_NEW_PRIVS 38 |
|||
#endif |
|||
|
|||
#ifndef PR_SET_CHILD_SUBREAPER |
|||
#define PR_SET_CHILD_SUBREAPER 36 |
|||
#endif |
|||
|
|||
#ifndef MAX_HANDLE_SZ |
|||
#define MAX_HANDLE_SZ 128 |
|||
#endif |
|||
|
|||
#if defined __x86_64__ |
|||
# ifndef __NR_name_to_handle_at |
|||
# define __NR_name_to_handle_at 303 |
|||
# endif |
|||
#elif defined __i386__ |
|||
# ifndef __NR_name_to_handle_at |
|||
# define __NR_name_to_handle_at 341 |
|||
# endif |
|||
#elif defined __arm__ |
|||
# ifndef __NR_name_to_handle_at |
|||
# define __NR_name_to_handle_at 370 |
|||
# endif |
|||
#elif defined __powerpc__ |
|||
# ifndef __NR_name_to_handle_at |
|||
# define __NR_name_to_handle_at 345 |
|||
# endif |
|||
#else |
|||
# ifndef __NR_name_to_handle_at |
|||
# error __NR_name_to_handle_at is not defined |
|||
# endif |
|||
#endif |
|||
|
|||
#if !HAVE_DECL_NAME_TO_HANDLE_AT |
|||
struct file_handle { |
|||
unsigned int handle_bytes; |
|||
int handle_type; |
|||
unsigned char f_handle[0]; |
|||
}; |
|||
|
|||
static inline int name_to_handle_at(int fd, const char *name, struct file_handle *handle, int *mnt_id, int flags) { |
|||
return syscall(__NR_name_to_handle_at, fd, name, handle, mnt_id, flags); |
|||
} |
|||
#endif |
|||
|
|||
#ifndef HAVE_SECURE_GETENV |
|||
# ifdef HAVE___SECURE_GETENV |
|||
# define secure_getenv __secure_getenv |
|||
# else |
|||
# error neither secure_getenv nor __secure_getenv are available |
|||
# endif |
|||
#endif |
|||
|
|||
#ifndef CIFS_MAGIC_NUMBER |
|||
#define CIFS_MAGIC_NUMBER 0xFF534D42 |
|||
#endif |
|||
@ -0,0 +1,32 @@ |
|||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
|||
|
|||
#ifndef foomkdirhfoo |
|||
#define foomkdirhfoo |
|||
|
|||
/***
|
|||
This file is part of systemd. |
|||
|
|||
Copyright 2010 Lennart Poettering |
|||
|
|||
systemd is free software; you can redistribute it and/or modify it |
|||
under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation; either version 2.1 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
systemd 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|||
***/ |
|||
|
|||
int mkdir_label(const char *path, mode_t mode); |
|||
int mkdir_safe(const char *path, mode_t mode, uid_t uid, gid_t gid); |
|||
int mkdir_safe_label(const char *path, mode_t mode, uid_t uid, gid_t gid); |
|||
int mkdir_parents(const char *path, mode_t mode); |
|||
int mkdir_parents_label(const char *path, mode_t mode); |
|||
int mkdir_p(const char *path, mode_t mode); |
|||
int mkdir_p_label(const char *path, mode_t mode); |
|||
#endif |
|||
@ -0,0 +1,615 @@ |
|||
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ |
|||
|
|||
#pragma once |
|||
|
|||
/***
|
|||
This file is part of systemd. |
|||
|
|||
Copyright 2010 Lennart Poettering |
|||
|
|||
systemd is free software; you can redistribute it and/or modify it |
|||
under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation; either version 2.1 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
systemd 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 |
|||
Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|||
***/ |
|||
|
|||
#include <inttypes.h> |
|||
#include <time.h> |
|||
#include <sys/time.h> |
|||
#include <stdarg.h> |
|||
#include <stdbool.h> |
|||
#include <stdlib.h> |
|||
#include <stdio.h> |
|||
#include <signal.h> |
|||
#include <sched.h> |
|||
#include <limits.h> |
|||
#include <sys/types.h> |
|||
#include <sys/stat.h> |
|||
#include <dirent.h> |
|||
#include <sys/resource.h> |
|||
#include <stddef.h> |
|||
|
|||
#include "macro.h" |
|||
|
|||
typedef uint64_t usec_t; |
|||
typedef uint64_t nsec_t; |
|||
|
|||
typedef struct dual_timestamp { |
|||
usec_t realtime; |
|||
usec_t monotonic; |
|||
} dual_timestamp; |
|||
|
|||
union dirent_storage { |
|||
struct dirent de; |
|||
uint8_t storage[offsetof(struct dirent, d_name) + |
|||
((NAME_MAX + 1 + sizeof(long)) & ~(sizeof(long) - 1))]; |
|||
}; |
|||
|
|||
#define MSEC_PER_SEC 1000ULL |
|||
#define USEC_PER_SEC 1000000ULL |
|||
#define USEC_PER_MSEC 1000ULL |
|||
#define NSEC_PER_SEC 1000000000ULL |
|||
#define NSEC_PER_MSEC 1000000ULL |
|||
#define NSEC_PER_USEC 1000ULL |
|||
|
|||
#define USEC_PER_MINUTE (60ULL*USEC_PER_SEC) |
|||
#define NSEC_PER_MINUTE (60ULL*NSEC_PER_SEC) |
|||
#define USEC_PER_HOUR (60ULL*USEC_PER_MINUTE) |
|||
#define NSEC_PER_HOUR (60ULL*NSEC_PER_MINUTE) |
|||
#define USEC_PER_DAY (24ULL*USEC_PER_HOUR) |
|||
#define NSEC_PER_DAY (24ULL*NSEC_PER_HOUR) |
|||
#define USEC_PER_WEEK (7ULL*USEC_PER_DAY) |
|||
#define NSEC_PER_WEEK (7ULL*NSEC_PER_DAY) |
|||
#define USEC_PER_MONTH (2629800ULL*USEC_PER_SEC) |
|||
#define NSEC_PER_MONTH (2629800ULL*NSEC_PER_SEC) |
|||
#define USEC_PER_YEAR (31557600ULL*USEC_PER_SEC) |
|||
#define NSEC_PER_YEAR (31557600ULL*NSEC_PER_SEC) |
|||
|
|||
/* What is interpreted as whitespace? */ |
|||
#define WHITESPACE " \t\n\r" |
|||
#define NEWLINE "\n\r" |
|||
#define QUOTES "\"\'" |
|||
#define COMMENTS "#;\n" |
|||
|
|||
#define FORMAT_TIMESTAMP_MAX (5+11+9+4+1) |
|||
#define FORMAT_TIMESTAMP_PRETTY_MAX 256 |
|||
#define FORMAT_TIMESPAN_MAX 64 |
|||
#define FORMAT_BYTES_MAX 8 |
|||
|
|||
#define ANSI_HIGHLIGHT_ON "\x1B[1;39m" |
|||
#define ANSI_HIGHLIGHT_RED_ON "\x1B[1;31m" |
|||
#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m" |
|||
#define ANSI_HIGHLIGHT_YELLOW_ON "\x1B[1;33m" |
|||
#define ANSI_HIGHLIGHT_OFF "\x1B[0m" |
|||
|
|||
bool is_efiboot(void); |
|||
|
|||
usec_t now(clockid_t clock); |
|||
|
|||
dual_timestamp* dual_timestamp_get(dual_timestamp *ts); |
|||
dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u); |
|||
|
|||
#define dual_timestamp_is_set(ts) ((ts)->realtime > 0) |
|||
|
|||
usec_t timespec_load(const struct timespec *ts); |
|||
struct timespec *timespec_store(struct timespec *ts, usec_t u); |
|||
|
|||
usec_t timeval_load(const struct timeval *tv); |
|||
struct timeval *timeval_store(struct timeval *tv, usec_t u); |
|||
|
|||
size_t page_size(void); |
|||
#define PAGE_ALIGN(l) ALIGN_TO((l), page_size()) |
|||
|
|||
#define streq(a,b) (strcmp((a),(b)) == 0) |
|||
#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0) |
|||
|
|||
bool streq_ptr(const char *a, const char *b); |
|||
|
|||
#define new(t, n) ((t*) malloc_multiply(sizeof(t), (n))) |
|||
|
|||
#define new0(t, n) ((t*) calloc((n), sizeof(t))) |
|||
|
|||
#define newa(t, n) ((t*) alloca(sizeof(t)*(n))) |
|||
|
|||
#define newdup(t, p, n) ((t*) memdup_multiply(p, sizeof(t), (n))) |
|||
|
|||
#define malloc0(n) (calloc((n), 1)) |
|||
|
|||
static inline const char* yes_no(bool b) { |
|||
return b ? "yes" : "no"; |
|||
} |
|||
|
|||
static inline const char* strempty(const char *s) { |
|||
return s ? s : ""; |
|||
} |
|||
|
|||
static inline const char* strnull(const char *s) { |
|||
return s ? s : "(null)"; |
|||
} |
|||
|
|||
static inline const char *strna(const char *s) { |
|||
return s ? s : "n/a"; |
|||
} |
|||
|
|||
static inline bool isempty(const char *p) { |
|||
return !p || !p[0]; |
|||
} |
|||
|
|||
char *endswith(const char *s, const char *postfix); |
|||
char *startswith(const char *s, const char *prefix); |
|||
char *startswith_no_case(const char *s, const char *prefix); |
|||
|
|||
bool first_word(const char *s, const char *word); |
|||
|
|||
int close_nointr(int fd); |
|||
void close_nointr_nofail(int fd); |
|||
void close_many(const int fds[], unsigned n_fd); |
|||
|
|||
int parse_boolean(const char *v); |
|||
int parse_usec(const char *t, usec_t *usec); |
|||
int parse_nsec(const char *t, nsec_t *nsec); |
|||
int parse_bytes(const char *t, off_t *bytes); |
|||
int parse_pid(const char *s, pid_t* ret_pid); |
|||
int parse_uid(const char *s, uid_t* ret_uid); |
|||
#define parse_gid(s, ret_uid) parse_uid(s, ret_uid) |
|||
|
|||
int safe_atou(const char *s, unsigned *ret_u); |
|||
int safe_atoi(const char *s, int *ret_i); |
|||
|
|||
int safe_atollu(const char *s, unsigned long long *ret_u); |
|||
int safe_atolli(const char *s, long long int *ret_i); |
|||
|
|||
#if __WORDSIZE == 32 |
|||
static inline int safe_atolu(const char *s, unsigned long *ret_u) { |
|||
assert_cc(sizeof(unsigned long) == sizeof(unsigned)); |
|||
return safe_atou(s, (unsigned*) ret_u); |
|||
} |
|||
static inline int safe_atoli(const char *s, long int *ret_u) { |
|||
assert_cc(sizeof(long int) == sizeof(int)); |
|||
return safe_atoi(s, (int*) ret_u); |
|||
} |
|||
#else |
|||
static inline int safe_atolu(const char *s, unsigned long *ret_u) { |
|||
assert_cc(sizeof(unsigned long) == sizeof(unsigned long long)); |
|||
return safe_atollu(s, (unsigned long long*) ret_u); |
|||
} |
|||
static inline int safe_atoli(const char *s, long int *ret_u) { |
|||
assert_cc(sizeof(long int) == sizeof(long long int)); |
|||
return safe_atolli(s, (long long int*) ret_u); |
|||
} |
|||
#endif |
|||
|
|||
static inline int safe_atou32(const char *s, uint32_t *ret_u) { |
|||
assert_cc(sizeof(uint32_t) == sizeof(unsigned)); |
|||
return safe_atou(s, (unsigned*) ret_u); |
|||
} |
|||
|
|||
static inline int safe_atoi32(const char *s, int32_t *ret_i) { |
|||
assert_cc(sizeof(int32_t) == sizeof(int)); |
|||
return safe_atoi(s, (int*) ret_i); |
|||
} |
|||
|
|||
static inline int safe_atou64(const char *s, uint64_t *ret_u) { |
|||
assert_cc(sizeof(uint64_t) == sizeof(unsigned long long)); |
|||
return safe_atollu(s, (unsigned long long*) ret_u); |
|||
} |
|||
|
|||
static inline int safe_atoi64(const char *s, int64_t *ret_i) { |
|||
assert_cc(sizeof(int64_t) == sizeof(long long int)); |
|||
return safe_atolli(s, (long long int*) ret_i); |
|||
} |
|||
|
|||
char *split(const char *c, size_t *l, const char *separator, char **state); |
|||
char *split_quoted(const char *c, size_t *l, char **state); |
|||
|
|||
#define FOREACH_WORD(word, length, s, state) \ |
|||
for ((state) = NULL, (word) = split((s), &(length), WHITESPACE, &(state)); (word); (word) = split((s), &(length), WHITESPACE, &(state))) |
|||
|
|||
#define FOREACH_WORD_SEPARATOR(word, length, s, separator, state) \ |
|||
for ((state) = NULL, (word) = split((s), &(length), (separator), &(state)); (word); (word) = split((s), &(length), (separator), &(state))) |
|||
|
|||
#define FOREACH_WORD_QUOTED(word, length, s, state) \ |
|||
for ((state) = NULL, (word) = split_quoted((s), &(length), &(state)); (word); (word) = split_quoted((s), &(length), &(state))) |
|||
|
|||
pid_t get_parent_of_pid(pid_t pid, pid_t *ppid); |
|||
int get_starttime_of_pid(pid_t pid, unsigned long long *st); |
|||
|
|||
int write_one_line_file(const char *fn, const char *line); |
|||
int write_one_line_file_atomic(const char *fn, const char *line); |
|||
int read_one_line_file(const char *fn, char **line); |
|||
int read_full_file(const char *fn, char **contents, size_t *size); |
|||
|
|||
int parse_env_file(const char *fname, const char *separator, ...) _sentinel_; |
|||
int load_env_file(const char *fname, char ***l); |
|||
int write_env_file(const char *fname, char **l); |
|||
|
|||
char *strappend(const char *s, const char *suffix); |
|||
char *strnappend(const char *s, const char *suffix, size_t length); |
|||
|
|||
char *replace_env(const char *format, char **env); |
|||
char **replace_env_argv(char **argv, char **env); |
|||
|
|||
int readlink_malloc(const char *p, char **r); |
|||
int readlink_and_make_absolute(const char *p, char **r); |
|||
int readlink_and_canonicalize(const char *p, char **r); |
|||
|
|||
int reset_all_signal_handlers(void); |
|||
|
|||
char *strstrip(char *s); |
|||
char *delete_chars(char *s, const char *bad); |
|||
char *truncate_nl(char *s); |
|||
|
|||
char *file_in_same_dir(const char *path, const char *filename); |
|||
|
|||
int rmdir_parents(const char *path, const char *stop); |
|||
|
|||
int get_process_comm(pid_t pid, char **name); |
|||
int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line); |
|||
int get_process_exe(pid_t pid, char **name); |
|||
int get_process_uid(pid_t pid, uid_t *uid); |
|||
int get_process_gid(pid_t pid, gid_t *gid); |
|||
|
|||
char hexchar(int x); |
|||
int unhexchar(char c); |
|||
char octchar(int x); |
|||
int unoctchar(char c); |
|||
char decchar(int x); |
|||
int undecchar(char c); |
|||
|
|||
char *cescape(const char *s); |
|||
char *cunescape(const char *s); |
|||
char *cunescape_length(const char *s, size_t length); |
|||
char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix); |
|||
|
|||
char *xescape(const char *s, const char *bad); |
|||
|
|||
char *bus_path_escape(const char *s); |
|||
char *bus_path_unescape(const char *s); |
|||
|
|||
char *ascii_strlower(char *path); |
|||
|
|||
bool dirent_is_file(const struct dirent *de); |
|||
bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix); |
|||
|
|||
bool ignore_file(const char *filename); |
|||
|
|||
bool chars_intersect(const char *a, const char *b); |
|||
|
|||
char *format_timestamp(char *buf, size_t l, usec_t t); |
|||
char *format_timestamp_pretty(char *buf, size_t l, usec_t t); |
|||
char *format_timespan(char *buf, size_t l, usec_t t); |
|||
|
|||
int make_stdio(int fd); |
|||
int make_null_stdio(void); |
|||
int make_console_stdio(void); |
|||
|
|||
unsigned long long random_ull(void); |
|||
|
|||
/* For basic lookup tables with strictly enumerated entries */ |
|||
#define __DEFINE_STRING_TABLE_LOOKUP(name,type,scope) \ |
|||
scope const char *name##_to_string(type i) { \ |
|||
if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \ |
|||
return NULL; \ |
|||
return name##_table[i]; \ |
|||
} \ |
|||
scope type name##_from_string(const char *s) { \ |
|||
type i; \ |
|||
assert(s); \ |
|||
for (i = 0; i < (type)ELEMENTSOF(name##_table); i++) \ |
|||
if (name##_table[i] && \ |
|||
streq(name##_table[i], s)) \ |
|||
return i; \ |
|||
return (type) -1; \ |
|||
} \ |
|||
struct __useless_struct_to_allow_trailing_semicolon__ |
|||
|
|||
#define DEFINE_STRING_TABLE_LOOKUP(name,type) __DEFINE_STRING_TABLE_LOOKUP(name,type,) |
|||
#define DEFINE_PRIVATE_STRING_TABLE_LOOKUP(name,type) __DEFINE_STRING_TABLE_LOOKUP(name,type,static) |
|||
|
|||
/* For string conversions where numbers are also acceptable */ |
|||
#define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max) \ |
|||
int name##_to_string_alloc(type i, char **str) { \ |
|||
char *s; \ |
|||
int r; \ |
|||
if (i < 0 || i > max) \ |
|||
return -ERANGE; \ |
|||
if (i < (type) ELEMENTSOF(name##_table)) { \ |
|||
s = strdup(name##_table[i]); \ |
|||
if (!s) \ |
|||
return log_oom(); \ |
|||
} else { \ |
|||
r = asprintf(&s, "%u", i); \ |
|||
if (r < 0) \ |
|||
return log_oom(); \ |
|||
} \ |
|||
*str = s; \ |
|||
return 0; \ |
|||
} \ |
|||
type name##_from_string(const char *s) { \ |
|||
type i; \ |
|||
unsigned u = 0; \ |
|||
assert(s); \ |
|||
for (i = 0; i < (type)ELEMENTSOF(name##_table); i++) \ |
|||
if (name##_table[i] && \ |
|||
streq(name##_table[i], s)) \ |
|||
return i; \ |
|||
if (safe_atou(s, &u) >= 0 && u <= max) \ |
|||
return (type) u; \ |
|||
return (type) -1; \ |
|||
} \ |
|||
struct __useless_struct_to_allow_trailing_semicolon__ |
|||
|
|||
int fd_nonblock(int fd, bool nonblock); |
|||
int fd_cloexec(int fd, bool cloexec); |
|||
|
|||
int close_all_fds(const int except[], unsigned n_except); |
|||
|
|||
bool fstype_is_network(const char *fstype); |
|||
|
|||
int chvt(int vt); |
|||
|
|||
int read_one_char(FILE *f, char *ret, usec_t timeout, bool *need_nl); |
|||
int ask(char *ret, const char *replies, const char *text, ...); |
|||
|
|||
int reset_terminal_fd(int fd, bool switch_to_text); |
|||
int reset_terminal(const char *name); |
|||
|
|||
int open_terminal(const char *name, int mode); |
|||
int acquire_terminal(const char *name, bool fail, bool force, bool ignore_tiocstty_eperm, usec_t timeout); |
|||
int release_terminal(void); |
|||
|
|||
int flush_fd(int fd); |
|||
|
|||
int ignore_signals(int sig, ...); |
|||
int default_signals(int sig, ...); |
|||
int sigaction_many(const struct sigaction *sa, ...); |
|||
|
|||
int close_pipe(int p[]); |
|||
int fopen_temporary(const char *path, FILE **_f, char **_temp_path); |
|||
|
|||
ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll); |
|||
ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll); |
|||
|
|||
bool is_device_path(const char *path); |
|||
|
|||
int dir_is_empty(const char *path); |
|||
|
|||
void rename_process(const char name[8]); |
|||
|
|||
void sigset_add_many(sigset_t *ss, ...); |
|||
|
|||
bool hostname_is_set(void); |
|||
|
|||
char* gethostname_malloc(void); |
|||
char* getlogname_malloc(void); |
|||
char* getusername_malloc(void); |
|||
|
|||
int getttyname_malloc(int fd, char **r); |
|||
int getttyname_harder(int fd, char **r); |
|||
|
|||
int get_ctty_devnr(pid_t pid, dev_t *d); |
|||
int get_ctty(pid_t, dev_t *_devnr, char **r); |
|||
|
|||
int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid); |
|||
int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid); |
|||
|
|||
int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev); |
|||
int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev); |
|||
int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky); |
|||
int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky); |
|||
|
|||
int pipe_eof(int fd); |
|||
|
|||
cpu_set_t* cpu_set_malloc(unsigned *ncpus); |
|||
|
|||
int status_vprintf(const char *status, | |||