static void write_env_var(FILE *f, const char *v) {
const char *p;
p = strchr(v, '=');
if (!p) {
/* Fallback */
fputs_unlocked(v, f);
fputc_unlocked('\n', f);
return;
}
p++;
fwrite_unlocked(v, 1, p-v, f);
if (string_has_cc(p, NULL) || chars_intersect(p, WHITESPACE SHELL_NEED_QUOTES)) {
fputc_unlocked('\"', f);
for (; *p; p++) {
if (strchr(SHELL_NEED_ESCAPE, *p))
fputc_unlocked('\\', f);
fputc_unlocked(*p, f);
}
fputc_unlocked('\"', f);
} else
fputs_unlocked(p, f);
fputc_unlocked('\n', f);
}
static void write_resolv_conf_search(
OrderedSet *domains,
FILE *f) {
unsigned length = 0, count = 0;
Iterator i;
char *domain;
assert(domains);
assert(f);
fputs_unlocked("search", f);
ORDERED_SET_FOREACH(domain, domains, i) {
if (++count > MAXDNSRCH) {
fputs_unlocked("\n# Too many search domains configured, remaining ones ignored.", f);
break;
}
length += strlen(domain) + 1;
if (length > 256) {
fputs_unlocked("\n# Total length of all search domains is too long, remaining ones ignored.", f);
break;
}
fputc_unlocked(' ', f);
fputs_unlocked(domain, f);
}
fputs_unlocked("\n", f);
}
static int write_resolv_conf_contents(FILE *f, OrderedSet *dns, OrderedSet *domains) {
Iterator i;
fputs_unlocked("# This file is managed by man:systemd-resolved(8). Do not edit.\n#\n"
"# This is a dynamic resolv.conf file for connecting local clients directly to\n"
"# all known DNS servers.\n#\n"
"# Third party programs must not access this file directly, but only through the\n"
"# symlink at /etc/resolv.conf. To manage man:resolv.conf(5) in a different way,\n"
"# replace this symlink by a static file or a different symlink.\n#\n"
"# See man:systemd-resolved.service(8) for details about the supported modes of\n"
"# operation for /etc/resolv.conf.\n\n", f);
if (ordered_set_isempty(dns))
fputs_unlocked("# No DNS servers known.\n", f);
else {
unsigned count = 0;
DnsServer *s;
ORDERED_SET_FOREACH(s, dns, i)
write_resolv_conf_server(s, f, &count);
}
if (!ordered_set_isempty(domains))
write_resolv_conf_search(domains, f);
return fflush_and_check(f);
}
void printescape(unsigned char *s, unsigned int l) {
for (unsigned int i = 0; i < l; i++) {
switch (s[i]) {
case '<':
fputs_unlocked("<", stdout);
continue;
case '>':
fputs_unlocked(">", stdout);
continue;
case '&':
fputs_unlocked("&", stdout);
continue;
case '\'':
fputs_unlocked("'", stdout);
continue;
case '"':
fputs_unlocked(""", stdout);
continue;
case '\r':
fputs_unlocked(" ", stdout);
continue;
case '\n':
fputs_unlocked(" ", stdout);
continue;
case '\t':
fputs_unlocked("	", stdout);
continue;
default:
fputc_unlocked(s[i], stdout);
}
}
}
static void write_resolv_conf_server(DnsServer *s, FILE *f, unsigned *count) {
assert(s);
assert(f);
assert(count);
if (!dns_server_string(s)) {
log_warning("Our of memory, or invalid DNS address. Ignoring server.");
return;
}
/* Check if the DNS server is limited to particular domains;
* resolv.conf does not have a syntax to express that, so it must not
* appear as a global name server to avoid routing unrelated domains to
* it (which is a privacy violation, will most probably fail anyway,
* and adds unnecessary load) */
if (dns_server_limited_domains(s)) {
log_debug("DNS server %s has route-only domains, not using as global name server", dns_server_string(s));
return;
}
if (*count == MAXNS)
fputs_unlocked("# Too many DNS servers configured, the following entries may be ignored.\n", f);
(*count)++;
fprintf(f, "nameserver %s\n", dns_server_string(s));
}
void
vwarn (const char *format, __gnuc_va_list ap)
{
int error = errno;
flockfile (stderr);
if (_IO_fwide (stderr, 0) > 0)
{
__fwprintf (stderr, L"%s: ", __progname);
if (format)
{
convert_and_print (format, ap);
fputws_unlocked (L": ", stderr);
}
__set_errno (error);
__fwprintf (stderr, L"%m\n");
}
else
{
fprintf (stderr, "%s: ", __progname);
if (format)
{
vfprintf (stderr, format, ap);
fputs_unlocked (": ", stderr);
}
__set_errno (error);
fprintf (stderr, "%m\n");
}
funlockfile (stderr);
}
void
randomize(struct amino_acid *amino_acid, int amino_acid_size,
const char *title, int n, random_t *rand) {
struct amino_acid *lookup[LOOKUP_SIZE];
char line_buffer[LINE_LEN + 1];
int i, j;
line_buffer[LINE_LEN] = '\n';
fill_lookup(lookup, amino_acid, amino_acid_size);
fputs_unlocked(title, stdout);
for (i = 0, j = 0; i < n; i++, j++) {
if (j == LINE_LEN) {
fwrite_unlocked(line_buffer, LINE_LEN + 1, 1, stdout);
j = 0;
}
float r = random_next_lookup(rand);
struct amino_acid *u = lookup[(short)r];
while (unlikely(u->cprob_lookup < r)) {
++u;
}
line_buffer[j] = u->sym;
}
line_buffer[j] = '\n';
fwrite_unlocked(line_buffer, j + 1, 1, stdout);
}
int
main ()
{
fputs ("");
fputs_unlocked ("");
return 0;
}
// parse a var after $
char *getvar(FILE *input, FILE *fail) {
int braces = 0, c;
if ((c = getc_unlocked(input)) == EOF) return NULL;
if (c == '{') {
putc_unlocked(c, fail);
braces = 1;
}
else ungetc(c, input);
if ((c = getc_unlocked(input)) == EOF) return NULL;
if (!isalpha(c) && c != '_') {
putc_unlocked(c, fail);
return NULL;
}
ungetc(c, input);
char *var;
fscanf(input, "%m[A-Za-z0-9_]", &var);
if (!var) return NULL;
fputs_unlocked(var, fail);
if (braces) {
if ((c = getchar_unlocked()) == EOF) return NULL;
putc_unlocked(c, fail);
if (c != '}') {
ungetc(c, input);
return NULL;
}
}
return var;
}
// address: 8048a30
void proc4(int param1) {
__size32 eax; // r24
int edx; // r26
dcgettext(0, "Usage: %s [ignored command line arguments]\n or: %s OPTION\nExit with a status code indicating success.\n\nThese option names may not be abbreviated.\n\n", 5);
printf(eax);
dcgettext(0, " --help display this help and exit\n", 5);
edx = *0x804b7e0;
fputs_unlocked(eax, edx);
dcgettext(0, " --version output version information and exit\n", 5);
edx = *0x804b7e0;
fputs_unlocked(eax, edx);
dcgettext(0, "\nReport bugs to <%s>.\n", 5);
printf(eax);
exit(param1);
return;
}
void usage(int status )
{ char *tmp ;
char *tmp___0 ;
char *tmp___1 ;
char *tmp___2 ;
char *tmp___3 ;
char *tmp___4 ;
char *tmp___5 ;
char *tmp___6 ;
char *tmp___7 ;
char *tmp___8 ;
char *tmp___9 ;
char *tmp___10 ;
{
if (status != 0) {
tmp = gettext("Try `%s --help\' for more information.\n");
fprintf((FILE */* __restrict */)stderr, (char const */* __restrict */)tmp, program_name);
} else {
tmp___0 = gettext("Usage: %s OPTION... [FILE]...\n");
printf((char const */* __restrict */)tmp___0, program_name);
tmp___1 = gettext("Print selected parts of lines from each FILE to standard output.\n\n");
fputs_unlocked((char const */* __restrict */)tmp___1, (FILE */* __restrict */)stdout);
tmp___2 = gettext("Mandatory arguments to long options are mandatory for short options too.\n");
fputs_unlocked((char const */* __restrict */)tmp___2, (FILE */* __restrict */)stdout);
tmp___3 = gettext(" -b, --bytes=LIST select only these bytes\n -c, --characters=LIST select only these characters\n -d, --delimiter=DELIM use DELIM instead of TAB for field delimiter\n");
fputs_unlocked((char const */* __restrict */)tmp___3, (FILE */* __restrict */)stdout);
tmp___4 = gettext(" -f, --fields=LIST select only these fields; also print any line\n that contains no delimiter character, unless\n the -s option is specified\n -n (ignored)\n");
fputs_unlocked((char const */* __restrict */)tmp___4, (FILE */* __restrict */)stdout);
tmp___5 = gettext(" --complement complement the set of selected bytes, characters\n or fields\n");
fputs_unlocked((char const */* __restrict */)tmp___5, (FILE */* __restrict */)stdout);
tmp___6 = gettext(" -s, --only-delimited do not print lines not containing delimiters\n --output-delimiter=STRING use STRING as the output delimiter\n the default is to use the input delimiter\n");
fputs_unlocked((char const */* __restrict */)tmp___6, (FILE */* __restrict */)stdout);
tmp___7 = gettext(" --help display this help and exit\n");
fputs_unlocked((char const */* __restrict */)tmp___7, (FILE */* __restrict */)stdout);
tmp___8 = gettext(" --version output version information and exit\n");
fputs_unlocked((char const */* __restrict */)tmp___8, (FILE */* __restrict */)stdout);
tmp___9 = gettext("\nUse one, and only one of -b, -c or -f. Each LIST is made up of one\nrange, or many ranges separated by commas. Selected input is written\nin the same order that it is read, and is written exactly once.\n");
fputs_unlocked((char const */* __restrict */)tmp___9, (FILE */* __restrict */)stdout);
tmp___10 = gettext("Each range is one of:\n\n N N\'th byte, character or field, counted from 1\n N- from N\'th byte, character or field, to end of line\n N-M from N\'th to M\'th (included) byte, character or field\n -M from first to M\'th (included) byte, character or field\n\nWith no FILE, or when FILE is -, read standard input.\n");
fputs_unlocked((char const */* __restrict */)tmp___10, (FILE */* __restrict */)stdout);
emit_ancillary_info();
}
exit(status);
}
}
void use_fputs_unlocked() {
flockfile(stdout);
const char *s1 = "string='";
const char *s2 = "' count='";
const char *s3 = "'\n";
char buf[100];
fputs_unlocked(s1, stdout);
fputs_unlocked(string, stdout);
fputs_unlocked(s2, stdout);
snprintf(buf, sizeof buf, "%d", count);
fputs_unlocked(buf, stdout);
fputs_unlocked(s3, stdout);
funlockfile(stdout);
}
void version_etc_va( FILE *stream, char *command_name, char *package, char *version, va_list authors )
{
size_t n_authors;
{
va_list tmp_authors = authors;
n_authors = 0;
while ( tmp_authors += 4, tmp_authors[0] != 0 )
{
n_authors++;
}
if ( command_name != 0 )
fprintf( stream, "%s (%s) %s\n", command_name, package, version );
else
fprintf( stream, "%s %s\n", package, version );
fprintf( stream, version_etc_copyright, gettext( "(C)" ), 2008 );
fputs_unlocked( gettext( "\nLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\nThis is free software: you are free to change and redistribute it.\nThere is NO WARRANTY, to the extent permitted by law.\n\n" ), stream );
switch ( n_authors )
{
case 0:
abort( );
break;
case 1:
rpl_vfprintf( stream, gettext( "Written by %s.\n" ), authors );
break;
case 2:
rpl_vfprintf( stream, gettext( "Written by %s and %s.\n" ), authors );
break;
case 3:
rpl_vfprintf( stream, gettext( "Written by %s, %s, and %s.\n" ), authors );
break;
case 4:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\nand %s.\n" ), authors );
break;
case 5:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, and %s.\n" ), authors );
break;
case 6:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, %s, and %s.\n" ), authors );
break;
case 7:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, %s, %s, and %s.\n" ), authors );
break;
case 8:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, %s, %s, %s,\nand %s.\n" ), authors );
break;
case 9:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, %s, %s, %s,\n%s, and %s.\n" ), authors );
break;
default:
rpl_vfprintf( stream, gettext( "Written by %s, %s, %s,\n%s, %s, %s, %s,\n%s, %s, and others.\n" ), authors );
return;
break;
}
}
}
void write_uint(int x){
int i;
static char buf[12];
if(x==0){
putchar_unlocked('0');
return;
}
for(i=10; x; i--){
buf[i] = '0' + x % 10;
x /= 10;
}
fputs_unlocked(buf+1+i, stdout);
}
int _find_steals(Node * ptr, char * hist, char* limit, char level, FILE * out_file){
int i;
if(level == 26){
for(i = 0; i < ptr->len; i++){
fputs_unlocked((char *)ptr->children[i], out_file);
fputc_unlocked('\n', out_file);
}
return 0;
}
for (i = hist[level]; i < ptr->len && !(limit && i > hist[level] + limit[level]); i++)
if(ptr->children[i])
_find_steals(ptr->children[i], hist, limit, level + 1, out_file);
return 0;
}
void itoa(int value) {
char result[20];
char* ptr = result + sizeof(result);
int tmp_value;
*--ptr = '\0';
do {
tmp_value = value;
value /= 10;
*--ptr = "9876543210123456789"[9 + (tmp_value - value*10)];
} while ( value );
if (tmp_value < 0) *--ptr = '-';
fputs_unlocked(ptr, stdout);
}
void
vwarn (const char *format, __gnuc_va_list ap)
{
int error = errno;
flockfile (stderr);
if (__progname)
fprintf (stderr, "%s: ", __progname);
if (format)
{
vfprintf (stderr, format, ap);
fputs_unlocked (": ", stderr);
}
__set_errno (error);
fprintf (stderr, "%m\n");
funlockfile (stderr);
}
int puts(const char *str)
{
int res;
lock_lock(&(stdout->lock));
do {
res = fputs_unlocked(str, stdout);
if(res == EOF) {
res = EOF;
break;
}
if(putchar_unlocked('\n') == EOF) {
res = EOF;
break;
}
res++;
} while(0);
lock_unlock(&(stdout->lock));
return res;
}
__inline static void emit_ancillary_info(void)
{ char *tmp ;
char *tmp___0 ;
char *tmp___1 ;
char *tmp___2 ;
char const *lc_messages ;
char *tmp___3 ;
char *tmp___4 ;
char *tmp___5 ;
int tmp___6 ;
char *tmp___7 ;
char *tmp___8 ;
{
tmp = last_component(program_name);
tmp___0 = gettext("\nReport %s bugs to %s\n");
printf((char const */* __restrict */)tmp___0, tmp, "*****@*****.**");
tmp___1 = gettext("%s home page: <http://www.gnu.org/software/%s/>\n");
printf((char const */* __restrict */)tmp___1, "GNU coreutils", "coreutils");
tmp___2 = gettext("General help using GNU software: <http://www.gnu.org/gethelp/>\n");
fputs_unlocked((char const */* __restrict */)tmp___2, (FILE */* __restrict */)stdout);
tmp___3 = setlocale(5, (char const *)((void *)0));
lc_messages = (char const *)tmp___3;
if (lc_messages) {
tmp___6 = strncmp(lc_messages, "en_", 3UL);
if (tmp___6) {
tmp___4 = last_component(program_name);
tmp___5 = gettext("Report %s translation bugs to <http://translationproject.org/team/>\n");
printf((char const */* __restrict */)tmp___5, tmp___4);
} else {
}
} else {
}
tmp___7 = last_component(program_name);
tmp___8 = gettext("For complete documentation, run: info coreutils \'%s invocation\'\n");
printf((char const */* __restrict */)tmp___8, tmp___7);
return;
}
}
static void
write_auth_string (const char *field,
const char *str)
{
const unsigned char *at;
char buf[8];
fprintf (authf, ", \"%s\": \"", field);
for (at = (const unsigned char *)str; *at; at++)
{
if (*at == '\\' || *at == '\"' || *at < 0x1f)
{
snprintf (buf, sizeof (buf), "\\u%04x", (int)*at);
fputs_unlocked (buf, authf);
}
else
{
fputc_unlocked (*at, authf);
}
}
fputc_unlocked ('\"', authf);
}
void
repeat(const char *alu, const char *title, int n) {
int len = strlen(alu);
char buffer[len + LINE_LEN];
int pos = 0;
memcpy(buffer, alu, len);
memcpy(buffer + len, alu, LINE_LEN);
fputs_unlocked(title, stdout);
while (n > 0) {
int bytes = n > LINE_LEN ? LINE_LEN : n;
fwrite_unlocked(buffer + pos, bytes, 1, stdout);
pos += bytes;
if (pos > len) {
pos -= len;
}
fputc_unlocked('\n', stdout);
n -= bytes;
}
}
static int write_stub_resolv_conf_contents(FILE *f, OrderedSet *dns, OrderedSet *domains) {
fputs_unlocked("# This file is managed by man:systemd-resolved(8). Do not edit.\n"
"#\n"
"# This is a dynamic resolv.conf file for connecting local clients to the\n"
"# internal DNS stub resolver of systemd-resolved. This file lists all\n"
"# configured search domains.\n"
"#\n"
"# Run \"resolvectl status\" to see details about the uplink DNS servers\n"
"# currently in use.\n"
"#\n"
"# Third party programs must not access this file directly, but only through the\n"
"# symlink at /etc/resolv.conf. To manage man:resolv.conf(5) in a different way,\n"
"# replace this symlink by a static file or a different symlink.\n"
"#\n"
"# See man:systemd-resolved.service(8) for details about the supported modes of\n"
"# operation for /etc/resolv.conf.\n"
"\n"
"nameserver 127.0.0.53\n", f);
if (!ordered_set_isempty(domains))
write_resolv_conf_search(domains, f);
return fflush_and_check(f);
}
void dmn_loggerv(int level, const char* fmt, va_list ap) {
if(alt_stderr) {
#ifndef NDEBUG
time_t t = time(NULL);
struct tm tmp;
localtime_r(&t, &tmp);
char tstamp[10];
if(!strftime(tstamp, 10, "%T ", &tmp))
strcpy(tstamp, "--:--:-- ");
# if defined SYS_gettid && !defined __APPLE__
pid_t tid = syscall(SYS_gettid);
char tidbuf[16];
snprintf(tidbuf, 16, " [%i]", tid);
# endif
const char* pfx;
switch(level) {
case LOG_DEBUG: pfx = pfx_debug; break;
case LOG_INFO: pfx = pfx_info; break;
case LOG_WARNING: pfx = pfx_warning; break;
case LOG_ERR: pfx = pfx_err; break;
case LOG_CRIT: pfx = pfx_crit; break;
default: pfx = pfx_unknown; break;
}
flockfile(alt_stderr);
fputs_unlocked(tstamp, alt_stderr);
if(our_logname)
fputs_unlocked(our_logname, alt_stderr);
# if defined SYS_gettid && !defined __APPLE__
fputs_unlocked(tidbuf, alt_stderr);
# endif
fputs_unlocked(pfx, alt_stderr);
va_list apcpy;
va_copy(apcpy, ap);
vfprintf(alt_stderr, fmt, apcpy);
va_end(apcpy);
putc_unlocked('\n', alt_stderr);
fflush_unlocked(alt_stderr);
funlockfile(alt_stderr);
#else // NDEBUG
if(level != LOG_INFO || send_stderr_info) {
va_list apcpy;
va_copy(apcpy, ap);
flockfile(alt_stderr);
vfprintf(alt_stderr, fmt, apcpy);
va_end(apcpy);
putc_unlocked('\n', alt_stderr);
fflush_unlocked(alt_stderr);
funlockfile(alt_stderr);
}
#endif // NDEBUG
}
if(dmn_syslog_alive)
vsyslog(level, fmt, ap);
dmn_fmtbuf_reset();
}
char *
getpass (const char *prompt)
{
FILE *tty;
FILE *in, *out;
struct termios s, t;
bool tty_changed = false;
static char *buf;
static size_t bufsize;
ssize_t nread;
/* Try to write to and read from the terminal if we can.
If we can't open the terminal, use stderr and stdin. */
tty = fopen ("/dev/tty", "w+");
if (tty == NULL)
{
in = stdin;
out = stderr;
}
else
{
/* We do the locking ourselves. */
__fsetlocking (tty, FSETLOCKING_BYCALLER);
out = in = tty;
}
flockfile (out);
/* Turn echoing off if it is on now. */
#if HAVE_TCGETATTR
if (tcgetattr (fileno (in), &t) == 0)
{
/* Save the old one. */
s = t;
/* Tricky, tricky. */
t.c_lflag &= ~(ECHO | ISIG);
tty_changed = (tcsetattr (fileno (in), TCSAFLUSH | TCSASOFT, &t) == 0);
}
#endif
/* Write the prompt. */
fputs_unlocked (prompt, out);
fflush_unlocked (out);
/* Read the password. */
nread = getline (&buf, &bufsize, in);
/* According to the C standard, input may not be followed by output
on the same stream without an intervening call to a file
positioning function. Suppose in == out; then without this fseek
call, on Solaris, HP-UX, AIX, OSF/1, the previous input gets
echoed, whereas on IRIX, the following newline is not output as
it should be. POSIX imposes similar restrictions if fileno (in)
== fileno (out). The POSIX restrictions are tricky and change
from POSIX version to POSIX version, so play it safe and invoke
fseek even if in != out. */
fseeko (out, 0, SEEK_CUR);
if (buf != NULL)
{
if (nread < 0)
buf[0] = '\0';
else if (buf[nread - 1] == '\n')
{
/* Remove the newline. */
buf[nread - 1] = '\0';
if (tty_changed)
{
/* Write the newline that was not echoed. */
putc_unlocked ('\n', out);
}
}
}
/* Restore the original setting. */
#if HAVE_TCSETATTR
if (tty_changed)
tcsetattr (fileno (in), TCSAFLUSH | TCSASOFT, &s);
#endif
funlockfile (out);
call_fclose (tty);
return buf;
}
void
__vsyslog_chk(int pri, int flag, const char *fmt, va_list ap)
{
struct tm now_tm;
time_t now;
int fd;
FILE *f;
char *buf = 0;
size_t bufsize = 0;
size_t prioff, msgoff;
#ifndef NO_SIGPIPE
struct sigaction action, oldaction;
int sigpipe;
#endif
int saved_errno = errno;
char failbuf[3 * sizeof (pid_t) + sizeof "out of memory []"];
#define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
/* Check for invalid bits. */
if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
syslog(INTERNALLOG,
"syslog: unknown facility/priority: %x", pri);
pri &= LOG_PRIMASK|LOG_FACMASK;
}
/* Check priority against setlogmask values. */
if ((LOG_MASK (LOG_PRI (pri)) & LogMask) == 0)
return;
/* Set default facility if none specified. */
if ((pri & LOG_FACMASK) == 0)
pri |= LogFacility;
/* Build the message in a memory-buffer stream. */
f = open_memstream (&buf, &bufsize);
if (f == NULL)
{
/* We cannot get a stream. There is not much we can do but
emitting an error messages. */
char numbuf[3 * sizeof (pid_t)];
char *nump;
char *endp = __stpcpy (failbuf, "out of memory [");
pid_t pid = __getpid ();
nump = numbuf + sizeof (numbuf);
/* The PID can never be zero. */
do
*--nump = '0' + pid % 10;
while ((pid /= 10) != 0);
endp = __mempcpy (endp, nump, (numbuf + sizeof (numbuf)) - nump);
*endp++ = ']';
*endp = '\0';
buf = failbuf;
bufsize = endp - failbuf;
msgoff = 0;
}
else
{
__fsetlocking (f, FSETLOCKING_BYCALLER);
prioff = fprintf (f, "<%d>", pri);
(void) time (&now);
f->_IO_write_ptr += __strftime_l (f->_IO_write_ptr,
f->_IO_write_end
- f->_IO_write_ptr,
"%h %e %T ",
__localtime_r (&now, &now_tm),
_nl_C_locobj_ptr);
msgoff = ftell (f);
if (LogTag == NULL)
LogTag = __progname;
if (LogTag != NULL)
fputs_unlocked (LogTag, f);
if (LogStat & LOG_PID)
fprintf (f, "[%d]", (int) __getpid ());
if (LogTag != NULL)
{
putc_unlocked (':', f);
putc_unlocked (' ', f);
}
/* Restore errno for %m format. */
__set_errno (saved_errno);
/* We have the header. Print the user's format into the
buffer. */
if (flag == -1)
vfprintf (f, fmt, ap);
else
__vfprintf_chk (f, flag, fmt, ap);
/* Close the memory stream; this will finalize the data
into a malloc'd buffer in BUF. */
fclose (f);
}
/* Output to stderr if requested. */
if (LogStat & LOG_PERROR) {
struct iovec iov[2];
register struct iovec *v = iov;
v->iov_base = buf + msgoff;
v->iov_len = bufsize - msgoff;
/* Append a newline if necessary. */
if (buf[bufsize - 1] != '\n')
{
++v;
v->iov_base = (char *) "\n";
v->iov_len = 1;
}
__libc_cleanup_push (free, buf == failbuf ? NULL : buf);
/* writev is a cancellation point. */
(void)__writev(STDERR_FILENO, iov, v - iov + 1);
__libc_cleanup_pop (0);
}
/* Prepare for multiple users. We have to take care: open and
write are cancellation points. */
struct cleanup_arg clarg;
clarg.buf = buf;
clarg.oldaction = NULL;
__libc_cleanup_push (cancel_handler, &clarg);
__libc_lock_lock (syslog_lock);
#ifndef NO_SIGPIPE
/* Prepare for a broken connection. */
memset (&action, 0, sizeof (action));
action.sa_handler = sigpipe_handler;
sigemptyset (&action.sa_mask);
sigpipe = __sigaction (SIGPIPE, &action, &oldaction);
if (sigpipe == 0)
clarg.oldaction = &oldaction;
#endif
/* Get connected, output the message to the local logger. */
if (!connected)
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
/* If we have a SOCK_STREAM connection, also send ASCII NUL as
a record terminator. */
if (LogType == SOCK_STREAM)
++bufsize;
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0)
{
if (connected)
{
/* Try to reopen the syslog connection. Maybe it went
down. */
closelog_internal ();
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
}
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0)
{
closelog_internal (); /* attempt re-open next time */
/*
* Output the message to the console; don't worry
* about blocking, if console blocks everything will.
* Make sure the error reported is the one from the
* syslogd failure.
*/
if (LogStat & LOG_CONS &&
(fd = __open(_PATH_CONSOLE, O_WRONLY|O_NOCTTY, 0)) >= 0)
{
dprintf (fd, "%s\r\n", buf + msgoff);
(void)__close(fd);
}
}
}
#ifndef NO_SIGPIPE
if (sigpipe == 0)
__sigaction (SIGPIPE, &oldaction, (struct sigaction *) NULL);
#endif
/* End of critical section. */
__libc_cleanup_pop (0);
__libc_lock_unlock (syslog_lock);
if (buf != failbuf)
free (buf);
}
static int add_swap(
const char *what,
struct mntent *me,
bool noauto,
bool nofail) {
_cleanup_free_ char *name = NULL, *unit = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(what);
assert(me);
if (access("/proc/swaps", F_OK) < 0) {
log_info("Swap not supported, ignoring fstab swap entry for %s.", what);
return 0;
}
if (detect_container() > 0) {
log_info("Running in a container, ignoring fstab swap entry for %s.", what);
return 0;
}
r = unit_name_from_path(what, ".swap", &name);
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
unit = strjoin(arg_dest, "/", name);
if (!unit)
return log_oom();
f = fopen(unit, "wxe");
if (!f)
return log_error_errno(errno,
errno == EEXIST ?
"Failed to create swap unit file %s, as it already exists. Duplicate entry in /etc/fstab?" :
"Failed to create unit file %s: %m",
unit);
fputs_unlocked("# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=/etc/fstab\n"
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n\n"
"[Swap]\n", f);
r = write_what(f, what);
if (r < 0)
return r;
r = write_options(f, me->mnt_opts);
if (r < 0)
return r;
r = fflush_and_check(f);
if (r < 0)
return log_error_errno(r, "Failed to write unit file %s: %m", unit);
/* use what as where, to have a nicer error message */
r = generator_write_timeouts(arg_dest, what, what, me->mnt_opts, NULL);
if (r < 0)
return r;
if (!noauto) {
r = generator_add_symlink(arg_dest, SPECIAL_SWAP_TARGET,
nofail ? "wants" : "requires", name);
if (r < 0)
return r;
}
return 0;
}
static void
__vsyslogex_chk(int pri, int flag, pid_t cpid, pid_t ctid, const char *fmt, va_list ap) {
struct tm now_tm;
time_t now;
int fd;
FILE *f;
char *buf = 0;
size_t bufsize = 0;
size_t prioff, msgoff;
#ifndef NO_SIGPIPE
struct sigaction action, oldaction;
int sigpipe;
#endif
int saved_errno = errno;
char failbuf[3 * sizeof (pid_t) + sizeof "out of memory []"];
const int LogMask = setlogmask(0);
#ifdef _DEBUGFLAGS_H_
{
static unsigned int registered = 0;
if (unlikely(0 == registered)) {
registered = 1; /* dirty work around to avoid deadlock: syslogex->register->syslogex */
registered = (registerLibraryDebugFlags(&debugFlags) == EXIT_SUCCESS);
}
}
#endif /*_DEBUGFLAGS_H_*/
#define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
/* Check for invalid bits. */
if (unlikely(pri & ~(LOG_PRIMASK | LOG_FACMASK))) {
/*syslog(INTERNALLOG,
"syslog: unknown facility/priority: %x", pri);*/
WARNING_MSG("unknown facility/priority: %x", pri);
pri &= LOG_PRIMASK | LOG_FACMASK;
}
/* Check priority against setlogmask values. */
if (unlikely((LOG_MASK(LOG_PRI(pri)) & LogMask) == 0))
return;
/* Set default facility if none specified. */
if (unlikely((pri & LOG_FACMASK) == 0))
pri |= LogFacility;
/* Build the message in a memory-buffer stream. */
f = open_memstream(&buf, &bufsize);
if (unlikely(f == NULL)) {
/* We cannot get a stream. There is not much we can do but
emitting an error messages with the Process ID. */
char numbuf[3 * sizeof (pid_t)];
char *nump;
char *endp = __stpcpy(failbuf, "out of memory [");
pid_t pid = getpid();
nump = numbuf + sizeof (numbuf);
/* The PID can never be zero. */
do {
*--nump = '0' + pid % 10;
} while ((pid /= 10) != 0);
endp = mempcpy((void*) endp, (const void*) nump, (size_t) ((numbuf + sizeof (numbuf)) - nump));
*endp++ = ']';
*endp = '\0';
buf = failbuf;
bufsize = endp - failbuf;
msgoff = 0;
} else {
__fsetlocking(f, FSETLOCKING_BYCALLER);
prioff = fprintf(f, "<%d>", pri);
(void) time(&now);
f->_IO_write_ptr += strftime(f->_IO_write_ptr,
f->_IO_write_end - f->_IO_write_ptr,
"%h %e %T ",
localtime_r(&now, &now_tm));
/*f->_IO_write_ptr += strftime_l (f->_IO_write_ptr,
f->_IO_write_end - f->_IO_write_ptr,
"%h %e %T ",
localtime_r (&now, &now_tm));*/
msgoff = ftell(f);
if (LogTag == NULL)
LogTag = __progname;
if (LogTag != NULL)
fputs_unlocked(LogTag, f);
if (LogStat & LOG_PID) {
const pid_t pid = ((0 == cpid) ? getpid() : cpid);
if (LogStat & LOG_TID) {
const pid_t tid = ((0 == ctid) ? gettid() : ctid);
fprintf(f, "[%d:%d]", (int) pid, (int) tid);
} else {
fprintf(f, "[%d]", (int) pid);
}
}
if (LogStat & LOG_RDTSC) {
const unsigned long long int t = rdtsc();
fprintf(f, "(%llu)", t);
} /* (LogStat & LOG_RDTSC) */
if (LogStat & LOG_CLOCK) {
#if HAVE_CLOCK_GETTIME
struct timespec timeStamp;
if (clock_gettime(CLOCK_MONOTONIC,&timeStamp) == 0) {
fprintf(f,"(%lu.%.9d)",timeStamp.tv_sec,timeStamp.tv_nsec);
} else {
const int error = errno;
ERROR_MSG("clock_gettime CLOCK_MONOTONIC error %d (%m)",error);
}
#else
static unsigned int alreadyPrinted = 0;
if (unlikely(0 == alreadyPrinted)) {
ERROR_MSG("clock_gettime not available on this system");
alreadyPrinted = 1;
}
#endif
} /* (LogStat & LOG_CLOCK) */
if (LogStat & LOG_LEVEL) {
switch (LOG_PRI(pri)) {
case LOG_EMERG:
fprintf(f, "[EMERG]");
break;
case LOG_ALERT:
fprintf(f, "[ALERT]");
break;
case LOG_CRIT:
fprintf(f, "[CRIT]");
break;
case LOG_ERR:
fprintf(f, "[ERROR]");
break;
case LOG_WARNING:
fprintf(f, "[WARNING]");
break;
case LOG_NOTICE:
fprintf(f, "[NOTICE]");
break;
case LOG_INFO:
fprintf(f, "[INFO]");
break;
case LOG_DEBUG:
fprintf(f, "[DEBUG]");
break;
} /* switch(LOG_PRI(pri))*/
} /* (LogStat & LOG_LEVEL) */
if (LogTag != NULL) {
putc_unlocked(':', f);
putc_unlocked(' ', f);
}
/* Restore errno for %m format. */
__set_errno(saved_errno);
/* We have the header. Print the user's format into the
buffer. */
if (flag == -1) {
vfprintf(f, fmt, ap);
} else {
__vfprintf_chk(f, flag, fmt, ap);
}
/* Close the memory stream; this will finalize the data
into a malloc'd buffer in BUF. */
fclose(f);
}
/* Output to stderr if requested. */
if (LogStat & LOG_PERROR) {
struct iovec iov[2];
register struct iovec *v = iov;
v->iov_base = buf + msgoff;
v->iov_len = bufsize - msgoff;
/* Append a newline if necessary. */
if (buf[bufsize - 1] != '\n') {
++v;
v->iov_base = (char *) "\n";
v->iov_len = 1;
}
pthread_cleanup_push(free, buf == failbuf ? NULL : buf);
/* writev is a cancellation point. */
(void) writev(STDERR_FILENO, iov, v - iov + 1);
pthread_cleanup_pop(0);
}
/* Prepare for multiple users. We have to take care: open and
write are cancellation points. */
struct cleanup_arg clarg;
clarg.buf = buf;
clarg.oldaction = NULL;
pthread_cleanup_push(cancel_handler, &clarg);
pthread_mutex_lock(&syslogex_lock);
#ifndef NO_SIGPIPE
/* Prepare for a broken connection. */
memset(&action, 0, sizeof (action));
action.sa_handler = sigpipe_handler;
sigemptyset(&action.sa_mask);
sigpipe = __sigaction(SIGPIPE, &action, &oldaction);
if (sigpipe == 0)
clarg.oldaction = &oldaction;
#endif
/* Get connected, output the message to the local logger. */
if (!connected) {
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
}
/* If we have a SOCK_STREAM connection, also send ASCII NUL as
a record terminator. */
if (LogType == SOCK_STREAM) {
++bufsize;
}
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0) {
if (connected) {
/* Try to reopen the syslog connection. Maybe it went
down. */
closelog_internal();
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
}
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0) {
closelog_internal(); /* attempt re-open next time */
/*
* Output the message to the console; don't worry
* about blocking, if console blocks everything will.
* Make sure the error reported is the one from the
* syslogd failure.
*/
if (LogStat & LOG_CONS &&
(fd = __open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY, 0)) >= 0) {
dprintf(fd, "%s\r\n", buf + msgoff);
(void) __close(fd);
}
}
}
#ifndef NO_SIGPIPE
if (sigpipe == 0)
__sigaction(SIGPIPE, &oldaction, (struct sigaction *) NULL);
#endif
/* End of critical section. */
pthread_cleanup_pop(0);
pthread_mutex_unlock(&syslogex_lock);
if (buf != failbuf) {
free(buf);
}
}
#include <stdio.h>
#include <string.h>
#include "un-namespace.h"
#include "fvwrite.h"
#include "libc_private.h"
#include "local.h"
/*
* Write the given string to the given file.
*/
int
fputs(const char * __restrict s, FILE * __restrict fp)
{
int retval;
FLOCKFILE(fp);
retval = fputs_unlocked(s, fp);
FUNLOCKFILE(fp);
return (retval);
}
int
fputs_unlocked(const char * __restrict s, FILE * __restrict fp)
{
struct __suio uio;
struct __siov iov;
iov.iov_base = (void *)s;
iov.iov_len = uio.uio_resid = strlen(s);
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
ORIENT(fp, -1);
/* Copyright (c) 2016, Dennis Wölfing
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* libc/src/stdio/fputs.c
* Puts a string into a file.
*/
#include <stdio.h>
int fputs(const char* restrict s, FILE* restrict file) {
flockfile(file);
int result = fputs_unlocked(s, file);
funlockfile(file);
return result;
}
// address: 80498b0
void proc5(char *param1, FILE *param2, char param3[], char param4[], char param5[], __size32 *param6) {
__size32 eax; // r24
__size32 ebx; // r27
eax = *param6;
if (eax != 0) {
do {
eax = *(param6 + 4);
} while (eax != 0);
}
if (param3 == 0) {
fprintf(param2, "%s %s\n", param4, param5);
} else {
fprintf(param2, "%s (%s) %s\n", param3, param4, param5);
}
switch(ebx) {
case 0:
case 1:
L16:
L15:
dcgettext(0, param1, 5);
vfprintf();
eax = *(param2 + 20);
if (eax < *(param2 + 24)) {
*(__size8*)eax = 10;
*(__size32*)(param2 + 20)++;
L9:
eax = *0x804b7d0;
fputs_unlocked(eax, param2);
eax = *(param2 + 20);
if (eax < *(param2 + 24)) {
*(__size8*)eax = 10;
*(__size32*)(param2 + 20)++;
L4:
dcgettext(0, "This is free software; see the source for copying conditions. There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", 5);
fputs_unlocked(eax, param2);
return;
}
__overflow();
goto L4;
}
__overflow();
goto L9;
case 2:
goto L15;
case 3:
goto L16;
case 4:
goto L16;
case 5:
goto L16;
case 6:
goto L15;
case 7:
goto L15;
case 8:
goto L16;
case 9:
goto L16;
}
abort();
return;
}
