\n"
"
%s
\n", name);
else
fprintf (fp, ".SH %s\n", name);
in_section = 1;
}
}
/* Render a @item line to HTML. (LINE,LEN) gives the arguments of
* @item. Use NULL for LINE to close a possible open
. ITEMX
* flags a @itemx line. */
static void
write_html_item (FILE *fp, const char *line, size_t len, int itemx)
{
static int in_li;
const char *rest;
size_t n, n0;
int eol_action = 0;
int table_level = 0;
if (!itemx && in_li)
{
fprintf (fp, "\n");
in_li = 0;
}
if (line)
{
/* Trim the LF and skip leading spaces. */
if (len && line[len-1] == '\n')
len--;
for (; len && (*line == ' ' || *line == '\t'); len--, line++)
;
if (len)
{
rest = line;
for (n=0; n < len && !(*rest == ' ' || *rest == '\t'); n++, rest++)
;
n0 = n;
for (; n < len && (*rest == ' ' || *rest == '\t'); n++, rest++)
;
len -= n;
/* Now the first word is (LINE,N0) and the args are (REST,LEN) */
fprintf (fp, "%s
%.*s",
itemx? " ":"", (int)n0, line);
if (len)
{
fputs (" ", fp);
proc_texi_buffer (fp, rest, len, &table_level, &eol_action);
fputs ("", fp);
}
fputs ("\n", fp);
in_li = 1;
}
}
}
/* Process the texinfo command COMMAND (without the leading @) and
write output if needed to FP. REST is the remainder of the line
which should either point to an opening brace or to a white space.
The function returns the number of characters already processed
from REST. LEN is the usable length of REST. TABLE_LEVEL is used to
control the indentation of tables. */
static size_t
proc_texi_cmd (FILE *fp, const char *command, const char *rest, size_t len,
int *table_level, int *eol_action)
{
static struct {
const char *name; /* Name of the command. */
int what; /* What to do with this command. */
const char *lead_in; /* String to print with a opening brace. */
const char *lead_out;/* String to print with the closing brace. */
const char *html_in; /* Same as LEAD_IN but for HTML. */
const char *html_out;/* Same as LEAD_OUT but for HTML. */
} cmdtbl[] = {
{ "command", 0, "\\fB", "\\fR", "
", "" },
{ "code", 0, "\\fB", "\\fR", "
", "" },
{ "url", 0, "\\fB", "\\fR", "
", "" },
{ "sc", 0, "\\fB", "\\fR", "
", "" },
{ "var", 0, "\\fI", "\\fR", "
", "" },
{ "samp", 0, "\\(oq", "\\(cq" },
{ "kbd", 0, "\\(oq", "\\(cq" },
{ "file", 0, "\\(oq\\fI","\\fR\\(cq" },
{ "env", 0, "\\(oq\\fI","\\fR\\(cq" },
{ "acronym", 0 },
{ "dfn", 0 },
{ "option", 0, "\\fB", "\\fR", "
", "" },
{ "example", 1, ".RS 2\n.nf\n", NULL, "\n
\n", "\n
\n" },
{ "smallexample", 1, ".RS 2\n.nf\n", NULL, "\n
\n", "\n
\n" },
{ "asis", 7 },
{ "anchor", 7 },
{ "cartouche", 1 },
{ "ref", 0, "[", "]" },
{ "xref", 0, "See: [", "]" },
{ "pxref", 0, "see: [", "]" },
{ "uref", 0, "(\\fB", "\\fR)" },
{ "footnote",0, " ([", "])" },
{ "emph", 0, "\\fI", "\\fR", "
", "" },
{ "w", 1 },
{ "c", 5 },
{ "efindex", 1 },
{ "opindex", 1 },
{ "cpindex", 1 },
{ "cindex", 1 },
{ "noindent", 0 },
{ "section", 1 },
{ "chapter", 1 },
{ "subsection", 6, "\n.SS " },
{ "chapheading", 0},
{ "item", 2, ".TP\n.B " },
{ "itemx", 2, ".TQ\n.B " },
{ "table", 3, NULL, NULL, "
\n" },
{ "itemize", 3 },
{ "bullet", 0, "* " },
{ "*", 0, "\n.br"},
{ "/", 0 },
{ "end", 4 },
{ "quotation",1, ".RS\n\\fB" },
{ "value", 8 },
{ NULL }
};
size_t n;
int i;
const char *s;
const char *lead_out = NULL;
const char *html_out = NULL;
int ignore_args = 0;
for (i=0; cmdtbl[i].name && strcmp (cmdtbl[i].name, command); i++)
;
if (cmdtbl[i].name)
{
writestr (cmdtbl[i].lead_in, cmdtbl[i].html_in, fp);
lead_out = cmdtbl[i].lead_out;
html_out = cmdtbl[i].html_out;
switch (cmdtbl[i].what)
{
case 1: /* Throw away the entire line. */
s = memchr (rest, '\n', len);
return s? (s-rest)+1 : len;
case 2: /* Handle @item. */
if (htmlmode)
{
s = memchr (rest, '\n', len);
n = s? (s-rest)+1 : len;
write_html_item (fp, rest, n, !strcmp(cmdtbl[i].name, "itemx"));
return n;
}
break;
case 3: /* Handle table. */
if (++(*table_level) > 1)
{
write_html_item (fp, NULL, 0, 0);
writestr (".RS\n", "
\n", fp);
}
/* Now throw away the entire line. */
s = memchr (rest, '\n', len);
return s? (s-rest)+1 : len;
break;
case 4: /* Handle end. */
for (s=rest, n=len; n && (*s == ' ' || *s == '\t'); s++, n--)
;
if (n >= 5 && !memcmp (s, "table", 5)
&& (!n || s[5] == ' ' || s[5] == '\t' || s[5] == '\n'))
{
if (htmlmode)
write_html_item (fp, NULL, 0, 0);
if ((*table_level)-- > 1)
writestr (".RE\n", "
\n", fp);
else
writestr (".P\n", "\n", fp);
}
else if (n >= 7 && !memcmp (s, "example", 7)
&& (!n || s[7] == ' ' || s[7] == '\t' || s[7] == '\n'))
{
writestr (".fi\n.RE\n", "\n", fp);
}
else if (n >= 12 && !memcmp (s, "smallexample", 12)
&& (!n || s[12] == ' ' || s[12] == '\t' || s[12] == '\n'))
{
writestr (".fi\n.RE\n", "\n", fp);
}
else if (n >= 9 && !memcmp (s, "quotation", 9)
&& (!n || s[9] == ' ' || s[9] == '\t' || s[9] == '\n'))
{
writestr ("\\fR\n.RE\n", "xx", fp);
}
/* Now throw away the entire line. */
s = memchr (rest, '\n', len);
return s? (s-rest)+1 : len;
case 5: /* Handle special comments. */
for (s=rest, n=len; n && (*s == ' ' || *s == '\t'); s++, n--)
;
if (n >= 4 && !memcmp (s, "man:", 4))
{
s += 4;
n -= 4;
if (htmlmode)
{
if (!strncmp (s, ".RE\n", 4)
|| !strncmp (s, ".RS\n", 4))
;
else
inf ("unknown special comment \"man:\"");
}
else
{
for (; n && *s != '\n'; n--, s++)
writechr (*s, fp);
writechr ('\n', fp);
}
}
/* Now throw away the entire line. */
s = memchr (rest, '\n', len);
return s? (s-rest)+1 : len;
case 6:
*eol_action = 1;
break;
case 7:
ignore_args = 1;
break;
case 8:
ignore_args = 1;
if (*rest != '{')
{
err ("opening brace for command '%s' missing", command);
return len;
}
else
{
/* Find closing brace. */
for (s=rest+1, n=1; *s && n < len; s++, n++)
if (*s == '}')
break;
if (*s != '}')
{
err ("closing brace for command '%s' not found", command);
return len;
}
else
{
size_t rlen = s - (rest + 1);
macro_t m;
for (m = variablelist; m; m = m->next)
{
if (strlen (m->name) == rlen
&& !strncmp (m->name, rest+1, rlen))
break;
}
if (m)
writestr (m->value, m->value, fp);
else
inf ("texinfo variable '%.*s' is not set",
(int)rlen, rest+1);
}
}
break;
default:
break;
}
}
else /* macro */
{
macro_t m;
for (m = macrolist; m ; m = m->next)
if (!strcmp (m->name, command))
break;
if (m)
{
proc_texi_buffer (fp, m->value, strlen (m->value),
table_level, eol_action);
ignore_args = 1; /* Parameterized macros are not yet supported. */
}
else
inf ("texinfo command '%s' not supported (%.*s)", command,
(int)((s = memchr (rest, '\n', len)), (s? (s-rest) : len)), rest);
}
if (*rest == '{')
{
/* Find matching closing brace. */
for (s=rest+1, n=1, i=1; i && *s && n < len; s++, n++)
if (*s == '{')
i++;
else if (*s == '}')
i--;
if (i)
{
err ("closing brace for command '%s' not found", command);
return len;
}
if (n > 2 && !ignore_args)
proc_texi_buffer (fp, rest+1, n-2, table_level, eol_action);
}
else
n = 0;
writestr (lead_out, html_out, fp);
return n;
}
/* Process the string LINE with LEN bytes of Texinfo content. */
static void
proc_texi_buffer (FILE *fp, const char *line, size_t len,
int *table_level, int *eol_action)
{
const char *s;
char cmdbuf[256];
int cmdidx = 0;
int in_cmd = 0;
size_t n;
for (s=line; *s && len; s++, len--)
{
if (in_cmd)
{
if (in_cmd == 1)
{
switch (*s)
{
case '@': case '{': case '}':
writechr (*s, fp); in_cmd = 0;
break;
case ':': /* Not ending a sentence flag. */
in_cmd = 0;
break;
case '.': case '!': case '?': /* Ending a sentence. */
writechr (*s, fp); in_cmd = 0;
break;
case ' ': case '\t': case '\n': /* Non collapsing spaces. */
writechr (*s, fp); in_cmd = 0;
break;
default:
cmdidx = 0;
cmdbuf[cmdidx++] = *s;
in_cmd++;
break;
}
}
else if (*s == '{' || *s == ' ' || *s == '\t' || *s == '\n')
{
cmdbuf[cmdidx] = 0;
n = proc_texi_cmd (fp, cmdbuf, s, len, table_level, eol_action);
assert (n <= len);
s += n; len -= n;
s--; len++;
in_cmd = 0;
}
else if (cmdidx < sizeof cmdbuf -1)
cmdbuf[cmdidx++] = *s;
else
{
err ("texinfo command too long - ignored");
in_cmd = 0;
}
}
else if (*s == '@')
in_cmd = 1;
else if (*s == '\n')
{
switch (*eol_action)
{
case 1: /* Create a dummy paragraph. */
writestr ("\n\\ \n", "\n<-- dummy par -->\n", fp);
break;
default:
writechr (*s, fp);
}
*eol_action = 0;
}
else if (*s == '\\')
writestr ("\\\\", "\\\\", fp);
else
writechr (*s, fp);
}
if (in_cmd > 1)
{
cmdbuf[cmdidx] = 0;
n = proc_texi_cmd (fp, cmdbuf, s, len, table_level, eol_action);
assert (n <= len);
s += n; len -= n;
s--; len++;
/* in_cmd = 0; -- doc only */
}
}
/* Do something with the Texinfo line LINE. */
static void
parse_texi_line (FILE *fp, const char *line, int *table_level)
{
int eol_action = 0;
/* A quick test whether there are any texinfo commands. */
if (!strchr (line, '@'))
{
/* FIXME: In html mode escape HTML stuff. */
writestr (line, line, fp);
writechr ('\n', fp);
return;
}
proc_texi_buffer (fp, line, strlen (line), table_level, &eol_action);
writechr ('\n', fp);
}
/* Write all the lines LINES to FP. */
static void
write_content (FILE *fp, line_buffer_t lines)
{
line_buffer_t line;
int table_level = 0;
for (line = lines; line; line = line->next)
{
if (line->verbatim)
{
/* FIXME: IN HTML mode we need to employ a parser for roff
* markup. */
writestr (line->line, line->line, fp);
writechr ('\n', fp);
}
else
{
/* fputs ("TEXI---", fp); */
/* fputs (line->line, fp); */
/* fputs ("---\n", fp); */
parse_texi_line (fp, line->line, &table_level);
}
}
}
static int
is_standard_section (const char *name)
{
int i;
const char *s;
for (i=0; (s=standard_sections[i]); i++)
if (!strcmp (s, name))
return 1;
return 0;
}
/* Finish a page; that is sort the data and write it out to the file. */
static void
finish_page (void)
{
FILE *fp;
section_buffer_t sect = NULL;
int idx;
const char *s;
int i;
if (!thepage.name)
return; /* No page active. */
if (verbose)
inf ("finishing page '%s'", thepage.name);
if (opt_select)
{
if (!strcmp (opt_select, thepage.name))
{
inf ("selected '%s'", thepage.name );
fp = stdout;
}
else
{
fp = fopen ( "/dev/null", "w" );
if (!fp)
die ("failed to open /dev/null: %s\n", strerror (errno));
}
}
else if (opt_store)
{
- inf ("writing '%s'", thepage.name );
+ if (verbose)
+ inf ("writing '%s'", thepage.name );
fp = fopen ( thepage.name, "w" );
if (!fp)
die ("failed to create '%s': %s\n", thepage.name, strerror (errno));
}
else
fp = stdout;
if (write_th (fp))
goto leave;
for (idx=0; (s=standard_sections[idx]); idx++)
{
for (i=0; i < thepage.n_sections; i++)
{
sect = thepage.sections + i;
if (sect->name && !strcmp (s, sect->name))
break;
}
if (i == thepage.n_sections)
sect = NULL;
if (sect)
{
write_sh (fp, sect->name);
write_content (fp, sect->lines);
/* Now continue with all non standard sections directly
following this one. */
for (i++; i < thepage.n_sections; i++)
{
sect = thepage.sections + i;
if (sect->name && is_standard_section (sect->name))
break;
if (sect->name)
{
write_sh (fp, sect->name);
write_content (fp, sect->lines);
}
}
}
}
write_sh (fp, NULL);
if (write_bottom (fp))
goto leave;
leave:
if (fp != stdout)
fclose (fp);
free (thepage.name);
thepage.name = NULL;
/* FIXME: Cleanup the content. */
}
/* Parse one Texinfo file and create manpages according to the
embedded instructions. */
static void
parse_file (const char *fname, FILE *fp, char **section_name, int in_pause)
{
char *line;
int lnr = 0;
/* Fixme: The following state variables don't carry over to include
files. */
int skip_to_end = 0; /* Used to skip over menu entries. */
int skip_sect_line = 0; /* Skip after @mansect. */
int item_indent = 0; /* How far is the current @item indented. */
/* Helper to define a macro. */
char *macroname = NULL;
char *macrovalue = NULL;
size_t macrovaluesize = 0;
size_t macrovalueused = 0;
line = xmalloc (LINESIZE);
while (fgets (line, LINESIZE, fp))
{
size_t n = strlen (line);
int got_line = 0;
char *p, *pend;
lnr++;
if (!n || line[n-1] != '\n')
{
err ("%s:%d: trailing linefeed missing, line too long or "
"embedded Nul character", fname, lnr);
break;
}
line[--n] = 0;
/* Kludge to allow indentation of tables. */
for (p=line; *p == ' ' || *p == '\t'; p++)
;
if (*p)
{
if (*p == '@' && !strncmp (p+1, "item", 4))
item_indent = p - line; /* Set a new indent level. */
else if (p - line < item_indent)
item_indent = 0; /* Switch off indention. */
if (item_indent)
{
memmove (line, line+item_indent, n - item_indent + 1);
n -= item_indent;
}
}
if (*line == '@')
{
for (p=line+1, n=1; *p && *p != ' ' && *p != '\t'; p++)
n++;
while (*p == ' ' || *p == '\t')
p++;
}
else
p = line;
/* Take action on macro. */
if (macroname)
{
if (n == 4 && !memcmp (line, "@end", 4)
&& (line[4]==' '||line[4]=='\t'||!line[4])
&& !strncmp (p, "macro", 5)
&& (p[5]==' '||p[5]=='\t'||!p[5]))
{
if (macrovalueused)
macrovalue[--macrovalueused] = 0; /* Kill the last LF. */
macrovalue[macrovalueused] = 0; /* Terminate macro. */
macrovalue = xrealloc (macrovalue, macrovalueused+1);
set_macro (macroname, macrovalue);
macrovalue = NULL;
free (macroname);
macroname = NULL;
}
else
{
if (macrovalueused + strlen (line) + 2 >= macrovaluesize)
{
macrovaluesize += strlen (line) + 256;
macrovalue = xrealloc (macrovalue, macrovaluesize);
}
strcpy (macrovalue+macrovalueused, line);
macrovalueused += strlen (line);
macrovalue[macrovalueused++] = '\n';
}
continue;
}
if (n >= 5 && !memcmp (line, "@node", 5)
&& (line[5]==' '||line[5]=='\t'||!line[5]))
{
/* Completey ignore @node lines. */
continue;
}
if (skip_sect_line)
{
skip_sect_line = 0;
if (!strncmp (line, "@section", 8)
|| !strncmp (line, "@subsection", 11)
|| !strncmp (line, "@chapheading", 12))
continue;
}
/* We only parse lines we need and ignore the rest. There are a
few macros used to control this as well as one @ifset
command. Parts we know about are saved away into containers
separate for each section. */
/* First process ifset/ifclear commands. */
if (*line == '@')
{
if (n == 6 && !memcmp (line, "@ifset", 6)
&& (line[6]==' '||line[6]=='\t'))
{
for (p=line+7; *p == ' ' || *p == '\t'; p++)
;
if (!*p)
{
err ("%s:%d: name missing after \"@ifset\"", fname, lnr);
continue;
}
for (pend=p; *pend && *pend != ' ' && *pend != '\t'; pend++)
;
*pend = 0; /* Ignore rest of the line. */
push_condition (p, 1, fname, lnr);
continue;
}
else if (n == 8 && !memcmp (line, "@ifclear", 8)
&& (line[8]==' '||line[8]=='\t'))
{
for (p=line+9; *p == ' ' || *p == '\t'; p++)
;
if (!*p)
{
err ("%s:%d: name missing after \"@ifsclear\"", fname, lnr);
continue;
}
for (pend=p; *pend && *pend != ' ' && *pend != '\t'; pend++)
;
*pend = 0; /* Ignore rest of the line. */
push_condition (p, 0, fname, lnr);
continue;
}
else if (n == 4 && !memcmp (line, "@end", 4)
&& (line[4]==' '||line[4]=='\t')
&& !strncmp (p, "ifset", 5)
&& (p[5]==' '||p[5]=='\t'||!p[5]))
{
pop_condition (1, fname, lnr);
continue;
}
else if (n == 4 && !memcmp (line, "@end", 4)
&& (line[4]==' '||line[4]=='\t')
&& !strncmp (p, "ifclear", 7)
&& (p[7]==' '||p[7]=='\t'||!p[7]))
{
pop_condition (0, fname, lnr);
continue;
}
}
/* Take action on ifset/ifclear. */
if (!cond_is_active)
continue;
/* Process commands. */
if (*line == '@')
{
if (skip_to_end
&& n == 4 && !memcmp (line, "@end", 4)
&& (line[4]==' '||line[4]=='\t'||!line[4]))
{
skip_to_end = 0;
}
else if (cond_in_verbatim)
{
got_line = 1;
}
else if (n == 6 && !memcmp (line, "@macro", 6))
{
macroname = xstrdup (p);
macrovalue = xmalloc ((macrovaluesize = 1024));
macrovalueused = 0;
}
else if (n == 4 && !memcmp (line, "@set", 4))
{
set_variable (p);
}
else if (n == 8 && !memcmp (line, "@manpage", 8))
{
free (*section_name);
*section_name = NULL;
finish_page ();
start_page (p);
in_pause = 0;
}
else if (n == 8 && !memcmp (line, "@mansect", 8))
{
if (!thepage.name)
err ("%s:%d: section outside of a man page", fname, lnr);
else
{
free (*section_name);
*section_name = ascii_strupr (xstrdup (p));
in_pause = 0;
skip_sect_line = 1;
}
}
else if (n == 9 && !memcmp (line, "@manpause", 9))
{
if (!*section_name)
err ("%s:%d: pausing outside of a man section", fname, lnr);
else if (in_pause)
err ("%s:%d: already pausing", fname, lnr);
else
in_pause = 1;
}
else if (n == 8 && !memcmp (line, "@mancont", 8))
{
if (!*section_name)
err ("%s:%d: continue outside of a man section", fname, lnr);
else if (!in_pause)
err ("%s:%d: continue while not pausing", fname, lnr);
else
in_pause = 0;
}
else if (n == 5 && !memcmp (line, "@menu", 5)
&& (line[5]==' '||line[5]=='\t'||!line[5]))
{
skip_to_end = 1;
}
else if (n == 8 && !memcmp (line, "@include", 8)
&& (line[8]==' '||line[8]=='\t'||!line[8]))
{
char *incname = xstrdup (p);
FILE *incfp = fopen (incname, "r");
if (!incfp && opt_include && *opt_include && *p != '/')
{
free (incname);
incname = xmalloc (strlen (opt_include) + 1
+ strlen (p) + 1);
strcpy (incname, opt_include);
if ( incname[strlen (incname)-1] != '/' )
strcat (incname, "/");
strcat (incname, p);
incfp = fopen (incname, "r");
}
if (!incfp)
err ("can't open include file '%s': %s",
incname, strerror (errno));
else
{
parse_file (incname, incfp, section_name, in_pause);
fclose (incfp);
}
free (incname);
}
else if (n == 4 && !memcmp (line, "@bye", 4)
&& (line[4]==' '||line[4]=='\t'||!line[4]))
{
break;
}
else if (!skip_to_end)
got_line = 1;
}
else if (!skip_to_end)
got_line = 1;
if (got_line && cond_in_verbatim)
add_content (*section_name, line, 1);
else if (got_line && thepage.name && *section_name && !in_pause)
add_content (*section_name, line, 0);
}
if (ferror (fp))
err ("%s:%d: read error: %s", fname, lnr, strerror (errno));
free (macroname);
free (macrovalue);
free (line);
}
static void
top_parse_file (const char *fname, FILE *fp)
{
char *section_name = NULL; /* Name of the current section or NULL
if not in a section. */
macro_t m;
while (macrolist)
{
macro_t next = macrolist->next;
free (macrolist->value);
free (macrolist);
macrolist = next;
}
while (variablelist)
{
macro_t next = variablelist->next;
free (variablelist->value);
free (variablelist);
variablelist = next;
}
for (m=predefinedmacrolist; m; m = m->next)
set_macro (m->name, xstrdup ("1"));
cond_is_active = 1;
cond_in_verbatim = 0;
parse_file (fname, fp, §ion_name, 0);
free (section_name);
finish_page ();
}
int
main (int argc, char **argv)
{
int last_argc = -1;
const char *s;
opt_source = "GNU";
opt_release = "";
/* Define default macros. The trick is that these macros are not
defined when using the actual texinfo renderer. */
add_predefined_macro ("isman");
add_predefined_macro ("manverb");
/* Option parsing. */
if (argc)
{
argc--; argv++;
}
while (argc && last_argc != argc )
{
last_argc = argc;
if (!strcmp (*argv, "--"))
{
argc--; argv++;
break;
}
else if (!strcmp (*argv, "--help"))
{
puts (
"Usage: " PGM " [OPTION] [FILE]\n"
"Extract man pages from a Texinfo source.\n\n"
" --html render output as HTML\n"
" --source NAME use NAME as source field\n"
" --release STRING use STRING as the release field\n"
" --date EPOCH use EPOCH as publication date\n"
" --store write output using @manpage name\n"
" --select NAME only output pages with @manpage NAME\n"
" --verbose enable extra informational output\n"
" --debug enable additional debug output\n"
" --help display this help and exit\n"
" -I DIR also search in include DIR\n"
" -D MACRO define MACRO to 1\n\n"
"With no FILE, or when FILE is -, read standard input.\n\n"
"Report bugs to
.");
exit (0);
}
else if (!strcmp (*argv, "--version"))
{
puts (PGM " " VERSION "\n"
"Copyright (C) 2005, 2017 g10 Code GmbH\n"
"This program comes with ABSOLUTELY NO WARRANTY.\n"
"This is free software, and you are welcome to redistribute it\n"
"under certain conditions. See the file COPYING for details.");
exit (0);
}
else if (!strcmp (*argv, "--html"))
{
htmlmode = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--verbose"))
{
verbose = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--quiet"))
{
quiet = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--debug"))
{
verbose = debug = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--source"))
{
argc--; argv++;
if (argc)
{
opt_source = *argv;
argc--; argv++;
}
}
else if (!strcmp (*argv, "--release"))
{
argc--; argv++;
if (argc)
{
opt_release = *argv;
argc--; argv++;
}
}
else if (!strcmp (*argv, "--date"))
{
argc--; argv++;
if (argc)
{
opt_date = *argv;
argc--; argv++;
}
}
else if (!strcmp (*argv, "--store"))
{
opt_store = 1;
argc--; argv++;
}
else if (!strcmp (*argv, "--select"))
{
argc--; argv++;
if (argc)
{
opt_select = strrchr (*argv, '/');
if (opt_select)
opt_select++;
else
opt_select = *argv;
argc--; argv++;
}
}
else if (!strcmp (*argv, "-I"))
{
argc--; argv++;
if (argc)
{
opt_include = *argv;
argc--; argv++;
}
}
else if (!strcmp (*argv, "-D"))
{
argc--; argv++;
if (argc)
{
add_predefined_macro (*argv);
argc--; argv++;
}
}
}
if (argc > 1)
die ("usage: " PGM " [OPTION] [FILE] (try --help for more information)\n");
/* Take care of supplied timestamp for reproducible builds. See
* https://reproducible-builds.org/specs/source-date-epoch/ */
if (!opt_date && (s = getenv ("SOURCE_DATE_EPOCH")) && *s)
opt_date = s;
/* Start processing. */
if (argc && strcmp (*argv, "-"))
{
FILE *fp = fopen (*argv, "rb");
if (!fp)
die ("%s:0: can't open file: %s", *argv, strerror (errno));
top_parse_file (*argv, fp);
fclose (fp);
}
else
top_parse_file ("-", stdin);
return !!any_error;
}
/*
Local Variables:
compile-command: "gcc -Wall -g -Wall -o yat2m yat2m.c"
End:
*/
diff --git a/src/estream.c b/src/estream.c
index 0542f59..32f8f48 100644
--- a/src/estream.c
+++ b/src/estream.c
@@ -1,5542 +1,5796 @@
/* estream.c - Extended Stream I/O Library
* Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011,
* 2014, 2015, 2016, 2017 g10 Code GmbH
*
* This file is part of Libestream.
*
* Libestream 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.
*
* Libestream 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 Libestream; if not, see .
*
* ALTERNATIVELY, Libestream may be distributed under the terms of the
* following license, in which case the provisions of this license are
* required INSTEAD OF the GNU General Public License. If you wish to
* allow use of your version of this file only under the terms of the
* GNU General Public License, and not to allow others to use your
* version of this file under the terms of the following license,
* indicate your decision by deleting this paragraph and the license
* below.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, and the entire permission notice in its entirety,
* including the disclaimer of warranties.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef USE_ESTREAM_SUPPORT_H
# include
#endif
#ifdef HAVE_CONFIG_H
# include
#endif
#if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)
# define HAVE_W32_SYSTEM 1
# if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)
# define HAVE_W32CE_SYSTEM
# endif
#endif
#ifdef HAVE_SYS_TIME_H
# include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef HAVE_W32_SYSTEM
# ifdef HAVE_WINSOCK2_H
# include
# endif
# include
#else
# ifdef HAVE_POLL_H
# include
# else
# ifdef HAVE_SYS_SELECT_H
# include
# endif
# endif
#endif
/* Enable tracing. The value is the module name to be printed. */
/*#define ENABLE_TRACING "estream"*/
#include "gpgrt-int.h"
#include "estream-printf.h"
#include "thread.h"
#include "lock.h"
#ifndef O_BINARY
# define O_BINARY 0
#endif
#ifndef HAVE_DOSISH_SYSTEM
# ifdef HAVE_W32_SYSTEM
# define HAVE_DOSISH_SYSTEM 1
# endif
#endif
#ifdef HAVE_W32_SYSTEM
# ifndef S_IRGRP
# define S_IRGRP S_IRUSR
# endif
# ifndef S_IROTH
# define S_IROTH S_IRUSR
# endif
# ifndef S_IWGRP
# define S_IWGRP S_IWUSR
# endif
# ifndef S_IWOTH
# define S_IWOTH S_IWUSR
# endif
# ifndef S_IXGRP
# define S_IXGRP S_IXUSR
# endif
# ifndef S_IXOTH
# define S_IXOTH S_IXUSR
# endif
#endif
#if !defined (EWOULDBLOCK) && defined (HAVE_W32_SYSTEM)
/* Compatibility with errno.h from mingw-2.0 */
# define EWOULDBLOCK 140
#endif
#ifndef EAGAIN
# define EAGAIN EWOULDBLOCK
#endif
#ifdef HAVE_W32CE_SYSTEM
# define _set_errno(a) gpg_err_set_errno ((a))
/* Setmode is missing in cegcc but available since CE 5.0. */
int _setmode (int handle, int mode);
# define setmode(a,b) _setmode ((a),(b))
#else
# define _set_errno(a) do { errno = (a); } while (0)
#endif
#define IS_INVALID_FD(a) ((a) == -1)
/* Calculate array dimension. */
#ifndef DIM
#define DIM(array) (sizeof (array) / sizeof (*array))
#endif
/* A helper macro used to convert to a hex string. */
#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
/* Generally used types. */
typedef void *(*func_realloc_t) (void *mem, size_t size);
typedef void (*func_free_t) (void *mem);
/*
* A linked list to hold active stream objects.
* Protected by ESTREAM_LIST_LOCK.
*/
struct estream_list_s
{
struct estream_list_s *next;
estream_t stream; /* Entry is not used if NULL. */
};
typedef struct estream_list_s *estream_list_t;
static estream_list_t estream_list;
/*
* File descriptors registered for use as the standard file handles.
* Protected by ESTREAM_LIST_LOCK.
*/
static int custom_std_fds[3];
static unsigned char custom_std_fds_valid[3];
/*
* A lock object to protect ESTREAM LIST, CUSTOM_STD_FDS and
* CUSTOM_STD_FDS_VALID. Used by lock_list() and unlock_list().
*/
GPGRT_LOCK_DEFINE (estream_list_lock);
/*
* Error code replacements.
*/
#ifndef EOPNOTSUPP
# define EOPNOTSUPP ENOSYS
#endif
/* Local prototypes. */
static void fname_set_internal (estream_t stream, const char *fname, int quote);
/*
* Memory allocation wrappers used in this file.
*/
static void *
mem_alloc (size_t n)
{
return _gpgrt_malloc (n);
}
static void *
mem_realloc (void *p, size_t n)
{
return _gpgrt_realloc (p, n);
}
static void
mem_free (void *p)
{
if (p)
_gpgrt_free (p);
}
/*
* A Windows helper function to map a W32 API error code to a standard
* system error code. That actually belong into sysutils but to allow
* standalone use of estream we keep it here.
*/
#ifdef HAVE_W32_SYSTEM
static int
map_w32_to_errno (DWORD w32_err)
{
switch (w32_err)
{
case 0:
return 0;
case ERROR_FILE_NOT_FOUND:
return ENOENT;
case ERROR_PATH_NOT_FOUND:
return ENOENT;
case ERROR_ACCESS_DENIED:
return EPERM; /* ReactOS uses EACCES ("Permission denied") and
* is likely right because they used an
* undocumented function to associate the error
* codes. However we have always used EPERM
* ("Operation not permitted", e.g. function is
* required to be called by root) and we better
* stick to that to avoid surprising bugs. */
case ERROR_INVALID_HANDLE:
return EBADF;
case ERROR_INVALID_BLOCK:
return ENOMEM;
case ERROR_NOT_ENOUGH_MEMORY:
return ENOMEM;
case ERROR_NO_DATA:
return EPIPE;
case ERROR_ALREADY_EXISTS:
return EEXIST;
/* This mapping has been taken from reactOS. */
case ERROR_TOO_MANY_OPEN_FILES: return EMFILE;
case ERROR_ARENA_TRASHED: return ENOMEM;
case ERROR_BAD_ENVIRONMENT: return E2BIG;
case ERROR_BAD_FORMAT: return ENOEXEC;
case ERROR_INVALID_DRIVE: return ENOENT;
case ERROR_CURRENT_DIRECTORY: return EACCES;
case ERROR_NOT_SAME_DEVICE: return EXDEV;
case ERROR_NO_MORE_FILES: return ENOENT;
case ERROR_WRITE_PROTECT: return EACCES;
case ERROR_BAD_UNIT: return EACCES;
case ERROR_NOT_READY: return EACCES;
case ERROR_BAD_COMMAND: return EACCES;
case ERROR_CRC: return EACCES;
case ERROR_BAD_LENGTH: return EACCES;
case ERROR_SEEK: return EACCES;
case ERROR_NOT_DOS_DISK: return EACCES;
case ERROR_SECTOR_NOT_FOUND: return EACCES;
case ERROR_OUT_OF_PAPER: return EACCES;
case ERROR_WRITE_FAULT: return EACCES;
case ERROR_READ_FAULT: return EACCES;
case ERROR_GEN_FAILURE: return EACCES;
case ERROR_SHARING_VIOLATION: return EACCES;
case ERROR_LOCK_VIOLATION: return EACCES;
case ERROR_WRONG_DISK: return EACCES;
case ERROR_SHARING_BUFFER_EXCEEDED: return EACCES;
case ERROR_BAD_NETPATH: return ENOENT;
case ERROR_NETWORK_ACCESS_DENIED: return EACCES;
case ERROR_BAD_NET_NAME: return ENOENT;
case ERROR_FILE_EXISTS: return EEXIST;
case ERROR_CANNOT_MAKE: return EACCES;
case ERROR_FAIL_I24: return EACCES;
case ERROR_NO_PROC_SLOTS: return EAGAIN;
case ERROR_DRIVE_LOCKED: return EACCES;
case ERROR_BROKEN_PIPE: return EPIPE;
case ERROR_DISK_FULL: return ENOSPC;
case ERROR_INVALID_TARGET_HANDLE: return EBADF;
case ERROR_WAIT_NO_CHILDREN: return ECHILD;
case ERROR_CHILD_NOT_COMPLETE: return ECHILD;
case ERROR_DIRECT_ACCESS_HANDLE: return EBADF;
case ERROR_SEEK_ON_DEVICE: return EACCES;
case ERROR_DIR_NOT_EMPTY: return ENOTEMPTY;
case ERROR_NOT_LOCKED: return EACCES;
case ERROR_BAD_PATHNAME: return ENOENT;
case ERROR_MAX_THRDS_REACHED: return EAGAIN;
case ERROR_LOCK_FAILED: return EACCES;
case ERROR_INVALID_STARTING_CODESEG: return ENOEXEC;
case ERROR_INVALID_STACKSEG: return ENOEXEC;
case ERROR_INVALID_MODULETYPE: return ENOEXEC;
case ERROR_INVALID_EXE_SIGNATURE: return ENOEXEC;
case ERROR_EXE_MARKED_INVALID: return ENOEXEC;
case ERROR_BAD_EXE_FORMAT: return ENOEXEC;
case ERROR_ITERATED_DATA_EXCEEDS_64k: return ENOEXEC;
case ERROR_INVALID_MINALLOCSIZE: return ENOEXEC;
case ERROR_DYNLINK_FROM_INVALID_RING: return ENOEXEC;
case ERROR_IOPL_NOT_ENABLED: return ENOEXEC;
case ERROR_INVALID_SEGDPL: return ENOEXEC;
case ERROR_AUTODATASEG_EXCEEDS_64k: return ENOEXEC;
case ERROR_RING2SEG_MUST_BE_MOVABLE: return ENOEXEC;
case ERROR_RELOC_CHAIN_XEEDS_SEGLIM: return ENOEXEC;
case ERROR_INFLOOP_IN_RELOC_CHAIN: return ENOEXEC;
case ERROR_FILENAME_EXCED_RANGE: return ENOENT;
case ERROR_NESTING_NOT_ALLOWED: return EAGAIN;
case ERROR_NOT_ENOUGH_QUOTA: return ENOMEM;
default:
return EIO;
}
}
/* Wrapper to be used by other modules to set ERRNO from the Windows
* error. EC may be -1 to get the last error. */
void
_gpgrt_w32_set_errno (int ec)
{
if (ec == -1)
ec = GetLastError ();
_set_errno (map_w32_to_errno (ec));
}
gpg_err_code_t
_gpgrt_w32_get_last_err_code (void)
{
int ec = GetLastError ();
errno = map_w32_to_errno (ec);
return _gpg_err_code_from_errno (errno);
}
#endif /*HAVE_W32_SYSTEM*/
/*
* Replacement for a missing memrchr.
*/
#ifndef HAVE_MEMRCHR
static void *
memrchr (const void *buffer, int c, size_t n)
{
const unsigned char *p = buffer;
for (p += n; n ; n--)
if (*--p == c)
return (void *)p;
return NULL;
}
#endif /*HAVE_MEMRCHR*/
/*
* Wrappers to lock a stream or the list of streams.
*/
#if 0
# define dbg_lock_0(f) fprintf (stderr, "estream: " f);
# define dbg_lock_1(f, a) fprintf (stderr, "estream: " f, (a));
# define dbg_lock_2(f, a, b) fprintf (stderr, "estream: " f, (a), (b));
#else
# define dbg_lock_0(f)
# define dbg_lock_1(f, a)
# define dbg_lock_2(f, a, b)
#endif
static int
init_stream_lock (estream_t _GPGRT__RESTRICT stream)
{
int rc;
if (!stream->intern->samethread)
{
dbg_lock_1 ("enter init_stream_lock for %p\n", stream);
memset (&stream->intern->lock, 0 , sizeof stream->intern->lock);
rc = _gpgrt_lock_init (&stream->intern->lock);
dbg_lock_2 ("leave init_stream_lock for %p: rc=%d\n", stream, rc);
}
else
rc = 0;
return rc;
}
static void
destroy_stream_lock (estream_t _GPGRT__RESTRICT stream)
{
if (!stream->intern->samethread)
{
dbg_lock_1 ("enter destroy_stream_lock for %p\n", stream);
_gpgrt_lock_destroy (&stream->intern->lock);
dbg_lock_1 ("leave destroy_stream_lock for %p\n", stream);
}
}
static void
lock_stream (estream_t _GPGRT__RESTRICT stream)
{
if (!stream->intern->samethread)
{
dbg_lock_1 ("enter lock_stream for %p\n", stream);
_gpgrt_lock_lock (&stream->intern->lock);
dbg_lock_1 ("leave lock_stream for %p\n", stream);
}
}
static int
trylock_stream (estream_t _GPGRT__RESTRICT stream)
{
int rc;
if (!stream->intern->samethread)
{
dbg_lock_1 ("enter trylock_stream for %p\n", stream);
rc = _gpgrt_lock_trylock (&stream->intern->lock)? 0 : -1;
dbg_lock_2 ("leave trylock_stream for %p: rc=%d\n", stream, rc);
}
else
rc = 0;
return rc;
}
static void
unlock_stream (estream_t _GPGRT__RESTRICT stream)
{
if (!stream->intern->samethread)
{
dbg_lock_1 ("enter unlock_stream for %p\n", stream);
_gpgrt_lock_unlock (&stream->intern->lock);
dbg_lock_1 ("leave unlock_stream for %p\n", stream);
}
}
static void
lock_list (void)
{
dbg_lock_0 ("enter lock_list\n");
_gpgrt_lock_lock (&estream_list_lock);
dbg_lock_0 ("leave lock_list\n");
}
static void
unlock_list (void)
{
dbg_lock_0 ("enter unlock_list\n");
_gpgrt_lock_unlock (&estream_list_lock);
dbg_lock_0 ("leave unlock_list\n");
}
#undef dbg_lock_0
#undef dbg_lock_1
#undef dbg_lock_2
/*
* Manipulation of the list of stream.
*/
/*
* Add STREAM to the list of registered stream objects. If
* WITH_LOCKED_LIST is true it is assumed that the list of streams is
* already locked. The implementation is straightforward: We first
* look for an unused entry in the list and use that; if none is
* available we put a new item at the head. We drawback of the
* strategy never to shorten the list is that a one time allocation of
* many streams will lead to scanning unused entries later. If that
* turns out to be a problem, we may either free some items from the
* list or append new entries at the end; or use a table. Returns 0
* on success; on error or non-zero is returned and ERRNO set.
*/
static int
do_list_add (estream_t stream, int with_locked_list)
{
estream_list_t item;
if (!with_locked_list)
lock_list ();
for (item = estream_list; item && item->stream; item = item->next)
;
if (!item)
{
item = mem_alloc (sizeof *item);
if (item)
{
item->next = estream_list;
estream_list = item;
}
}
if (item)
item->stream = stream;
if (!with_locked_list)
unlock_list ();
return item? 0 : -1;
}
/*
* Remove STREAM from the list of registered stream objects.
*/
static void
do_list_remove (estream_t stream, int with_locked_list)
{
estream_list_t item, item_prev = NULL;
if (!with_locked_list)
lock_list ();
for (item = estream_list; item; item = item->next)
if (item->stream == stream)
break;
else
item_prev = item;
if (item)
{
if (item_prev)
item_prev->next = item->next;
else
estream_list = item->next;
mem_free (item);
}
if (!with_locked_list)
unlock_list ();
}
/*
* The atexit handler for the entire gpgrt.
*/
static void
do_deinit (void)
{
/* Flush all streams. */
_gpgrt_fflush (NULL);
/* We should release the estream_list. However there is one
problem: That list is also used to search for the standard
estream file descriptors. If we would remove the entire list,
any use of es_foo in another atexit function may re-create the
list and the streams with possible undesirable effects. Given
that we don't close the stream either, it should not matter that
we keep the list and let the OS clean it up at process end. */
/* Reset the syscall clamp. */
_gpgrt_set_syscall_clamp (NULL, NULL);
}
/*
* Initialization of the estream module.
*/
int
_gpgrt_estream_init (void)
{
static int initialized;
if (!initialized)
{
initialized = 1;
atexit (do_deinit);
}
return 0;
}
/*
* Implementation of memory based I/O.
*/
/* Cookie for memory objects. */
typedef struct estream_cookie_mem
{
unsigned int modeflags; /* Open flags. */
unsigned char *memory; /* Allocated data buffer. */
size_t memory_size; /* Allocated size of MEMORY. */
size_t memory_limit; /* Caller supplied maximum allowed
allocation size or 0 for no limit. */
size_t offset; /* Current offset in MEMORY. */
size_t data_len; /* Used length of data in MEMORY. */
size_t block_size; /* Block size. */
struct {
unsigned int grow: 1; /* MEMORY is allowed to grow. */
} flags;
func_realloc_t func_realloc;
func_free_t func_free;
} *estream_cookie_mem_t;
/*
* Create function for memory objects. DATA is either NULL or a user
* supplied buffer with the initial conetnt of the memory buffer. If
* DATA is NULL, DATA_N and DATA_LEN need to be 0 as well. If DATA is
* not NULL, DATA_N gives the allocated size of DATA and DATA_LEN the
* used length in DATA. If this function succeeds DATA is now owned
* by this function. If GROW is false FUNC_REALLOC is not
* required.
*/
static int
func_mem_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie,
unsigned char *_GPGRT__RESTRICT data, size_t data_n,
size_t data_len,
size_t block_size, unsigned int grow,
func_realloc_t func_realloc, func_free_t func_free,
unsigned int modeflags,
size_t memory_limit)
{
estream_cookie_mem_t mem_cookie;
int err;
if (!data && (data_n || data_len))
{
_set_errno (EINVAL);
return -1;
}
if (grow && func_free && !func_realloc)
{
_set_errno (EINVAL);
return -1;
}
/* Round a memory limit up to the next block length. */
if (memory_limit && block_size)
{
memory_limit += block_size - 1;
memory_limit /= block_size;
memory_limit *= block_size;
}
mem_cookie = mem_alloc (sizeof (*mem_cookie));
if (!mem_cookie)
err = -1;
else
{
mem_cookie->modeflags = modeflags;
mem_cookie->memory = data;
mem_cookie->memory_size = data_n;
mem_cookie->memory_limit = memory_limit;
mem_cookie->offset = 0;
mem_cookie->data_len = data_len;
mem_cookie->block_size = block_size;
mem_cookie->flags.grow = !!grow;
mem_cookie->func_realloc
= grow? (func_realloc ? func_realloc : mem_realloc) : NULL;
mem_cookie->func_free = func_free ? func_free : mem_free;
*cookie = mem_cookie;
err = 0;
}
return err;
}
/*
* Read function for memory objects.
*/
static gpgrt_ssize_t
func_mem_read (void *cookie, void *buffer, size_t size)
{
estream_cookie_mem_t mem_cookie = cookie;
gpgrt_ssize_t ret;
if (!size) /* Just the pending data check. */
return (mem_cookie->data_len - mem_cookie->offset)? 0 : -1;
if (size > mem_cookie->data_len - mem_cookie->offset)
size = mem_cookie->data_len - mem_cookie->offset;
if (size)
{
memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);
mem_cookie->offset += size;
}
ret = size;
return ret;
}
/*
* Write function for memory objects.
*/
static gpgrt_ssize_t
func_mem_write (void *cookie, const void *buffer, size_t size)
{
estream_cookie_mem_t mem_cookie = cookie;
gpgrt_ssize_t ret;
size_t nleft;
if (!size)
return 0; /* A flush is a NOP for memory objects. */
if (mem_cookie->modeflags & O_APPEND)
{
/* Append to data. */
mem_cookie->offset = mem_cookie->data_len;
}
gpgrt_assert (mem_cookie->memory_size >= mem_cookie->offset);
nleft = mem_cookie->memory_size - mem_cookie->offset;
/* If we are not allowed to grow the buffer, limit the size to the
left space. */
if (!mem_cookie->flags.grow && size > nleft)
size = nleft;
/* Enlarge the memory buffer if needed. */
if (size > nleft)
{
unsigned char *newbuf;
size_t newsize;
if (!mem_cookie->memory_size)
newsize = size; /* Not yet allocated. */
else
newsize = mem_cookie->memory_size + (size - nleft);
if (newsize < mem_cookie->offset)
{
_set_errno (EINVAL);
return -1;
}
/* Round up to the next block length. BLOCK_SIZE should always
be set; we check anyway. */
if (mem_cookie->block_size)
{
newsize += mem_cookie->block_size - 1;
if (newsize < mem_cookie->offset)
{
_set_errno (EINVAL);
return -1;
}
newsize /= mem_cookie->block_size;
newsize *= mem_cookie->block_size;
}
/* Check for a total limit. */
if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
{
_set_errno (ENOSPC);
return -1;
}
gpgrt_assert (mem_cookie->func_realloc);
newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
if (!newbuf)
return -1;
mem_cookie->memory = newbuf;
mem_cookie->memory_size = newsize;
gpgrt_assert (mem_cookie->memory_size >= mem_cookie->offset);
nleft = mem_cookie->memory_size - mem_cookie->offset;
gpgrt_assert (size <= nleft);
}
memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);
if (mem_cookie->offset + size > mem_cookie->data_len)
mem_cookie->data_len = mem_cookie->offset + size;
mem_cookie->offset += size;
ret = size;
return ret;
}
/*
* Seek function for memory objects.
*/
static int
func_mem_seek (void *cookie, gpgrt_off_t *offset, int whence)
{
estream_cookie_mem_t mem_cookie = cookie;
gpgrt_off_t pos_new;
switch (whence)
{
case SEEK_SET:
pos_new = *offset;
break;
case SEEK_CUR:
pos_new = mem_cookie->offset += *offset;
break;
case SEEK_END:
pos_new = mem_cookie->data_len += *offset;
break;
default:
_set_errno (EINVAL);
return -1;
}
if (pos_new > mem_cookie->memory_size)
{
size_t newsize;
void *newbuf;
if (!mem_cookie->flags.grow)
{
_set_errno (ENOSPC);
return -1;
}
newsize = pos_new + mem_cookie->block_size - 1;
if (newsize < pos_new)
{
_set_errno (EINVAL);
return -1;
}
newsize /= mem_cookie->block_size;
newsize *= mem_cookie->block_size;
if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)
{
_set_errno (ENOSPC);
return -1;
}
gpgrt_assert (mem_cookie->func_realloc);
newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);
if (!newbuf)
return -1;
mem_cookie->memory = newbuf;
mem_cookie->memory_size = newsize;
}
if (pos_new > mem_cookie->data_len)
{
/* Fill spare space with zeroes. */
memset (mem_cookie->memory + mem_cookie->data_len,
0, pos_new - mem_cookie->data_len);
mem_cookie->data_len = pos_new;
}
mem_cookie->offset = pos_new;
*offset = pos_new;
return 0;
}
/*
* The IOCTL function for memory objects.
*/
static int
func_mem_ioctl (void *cookie, int cmd, void *ptr, size_t *len)
{
estream_cookie_mem_t mem_cookie = cookie;
int ret;
if (cmd == COOKIE_IOCTL_SNATCH_BUFFER)
{
/* Return the internal buffer of the stream to the caller and
invalidate it for the stream. */
*(void**)ptr = mem_cookie->memory;
*len = mem_cookie->data_len;
mem_cookie->memory = NULL;
mem_cookie->memory_size = 0;
mem_cookie->offset = 0;
ret = 0;
}
else if (cmd == COOKIE_IOCTL_TRUNCATE)
{
gpgrt_off_t length = *(gpgrt_off_t *)ptr;
ret = func_mem_seek (cookie, &length, SEEK_SET);
if (ret != -1)
mem_cookie->data_len = mem_cookie->offset;
}
else
{
_set_errno (EINVAL);
ret = -1;
}
return ret;
}
/*
* The destroy function for memory objects.
*/
static int
func_mem_destroy (void *cookie)
{
estream_cookie_mem_t mem_cookie = cookie;
if (cookie)
{
mem_cookie->func_free (mem_cookie->memory);
mem_free (mem_cookie);
}
return 0;
}
/*
* Access object for the memory functions.
*/
static struct cookie_io_functions_s estream_functions_mem =
{
{
func_mem_read,
func_mem_write,
func_mem_seek,
func_mem_destroy,
},
func_mem_ioctl,
};
/*
* Implementation of file descriptor based I/O.
*/
/* Cookie for fd objects. */
typedef struct estream_cookie_fd
{
int fd; /* The file descriptor we are using for actual output. */
int no_close; /* If set we won't close the file descriptor. */
int nonblock; /* Non-blocking mode is enabled. */
} *estream_cookie_fd_t;
/*
* Create function for objects indentified by a libc file descriptor.
*/
static int
func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close)
{
estream_cookie_fd_t fd_cookie;
int err;
trace (("enter: fd=%d mf=%x nc=%d", fd, modeflags, no_close));
fd_cookie = mem_alloc (sizeof (*fd_cookie));
if (! fd_cookie)
err = -1;
else
{
#ifdef HAVE_DOSISH_SYSTEM
/* Make sure it is in binary mode if requested. */
if ( (modeflags & O_BINARY) )
setmode (fd, O_BINARY);
#endif
fd_cookie->fd = fd;
fd_cookie->no_close = no_close;
fd_cookie->nonblock = !!(modeflags & O_NONBLOCK);
*cookie = fd_cookie;
err = 0;
}
trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err));
return err;
}
/*
* Read function for fd objects.
*/
static gpgrt_ssize_t
func_fd_read (void *cookie, void *buffer, size_t size)
{
estream_cookie_fd_t file_cookie = cookie;
gpgrt_ssize_t bytes_read;
trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
if (!size)
bytes_read = -1; /* We don't know whether anything is pending. */
else if (IS_INVALID_FD (file_cookie->fd))
{
_gpgrt_yield ();
bytes_read = 0;
}
else
{
_gpgrt_pre_syscall ();
do
{
bytes_read = read (file_cookie->fd, buffer, size);
}
while (bytes_read == -1 && errno == EINTR);
_gpgrt_post_syscall ();
}
trace_errno (bytes_read == -1, ("leave: bytes_read=%d", (int)bytes_read));
return bytes_read;
}
/*
* Write function for fd objects.
*/
static gpgrt_ssize_t
func_fd_write (void *cookie, const void *buffer, size_t size)
{
estream_cookie_fd_t file_cookie = cookie;
gpgrt_ssize_t bytes_written;
trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
if (IS_INVALID_FD (file_cookie->fd))
{
_gpgrt_yield ();
bytes_written = size; /* Yeah: Success writing to the bit bucket. */
}
else if (buffer)
{
_gpgrt_pre_syscall ();
do
{
bytes_written = write (file_cookie->fd, buffer, size);
}
while (bytes_written == -1 && errno == EINTR);
_gpgrt_post_syscall ();
}
else
bytes_written = size; /* Note that for a flush SIZE should be 0. */
trace_errno (bytes_written == -1,
("leave: bytes_written=%d", (int)bytes_written));
return bytes_written;
}
/*
* Seek function for fd objects.
*/
static int
func_fd_seek (void *cookie, gpgrt_off_t *offset, int whence)
{
estream_cookie_fd_t file_cookie = cookie;
gpgrt_off_t offset_new;
int err;
if (IS_INVALID_FD (file_cookie->fd))
{
_set_errno (ESPIPE);
err = -1;
}
else
{
_gpgrt_pre_syscall ();
offset_new = lseek (file_cookie->fd, *offset, whence);
_gpgrt_post_syscall ();
if (offset_new == -1)
err = -1;
else
{
*offset = offset_new;
err = 0;
}
}
return err;
}
/*
* The IOCTL function for fd objects.
*/
static int
func_fd_ioctl (void *cookie, int cmd, void *ptr, size_t *len)
{
estream_cookie_fd_t fd_cookie = cookie;
int ret;
if (cmd == COOKIE_IOCTL_NONBLOCK && !len)
{
fd_cookie->nonblock = !!ptr;
if (IS_INVALID_FD (fd_cookie->fd))
{
_set_errno (EINVAL);
ret = -1;
}
else
{
#ifdef _WIN32
_set_errno (EOPNOTSUPP); /* FIXME: Implement for Windows. */
ret = -1;
#else
_set_errno (0);
ret = fcntl (fd_cookie->fd, F_GETFL, 0);
if (ret == -1 && errno)
;
else if (fd_cookie->nonblock)
ret = fcntl (fd_cookie->fd, F_SETFL, (ret | O_NONBLOCK));
else
ret = fcntl (fd_cookie->fd, F_SETFL, (ret & ~O_NONBLOCK));
#endif
}
}
else
{
_set_errno (EINVAL);
ret = -1;
}
return ret;
}
/*
* The destroy function for fd objects.
*/
static int
func_fd_destroy (void *cookie)
{
estream_cookie_fd_t fd_cookie = cookie;
int err;
trace (("enter: cookie=%p", cookie));
if (fd_cookie)
{
if (IS_INVALID_FD (fd_cookie->fd))
err = 0;
else
err = fd_cookie->no_close? 0 : close (fd_cookie->fd);
mem_free (fd_cookie);
}
else
err = 0;
trace_errno (err,("leave: err=%d", err));
return err;
}
/*
* Access object for the fd functions.
*/
static struct cookie_io_functions_s estream_functions_fd =
{
{
func_fd_read,
func_fd_write,
func_fd_seek,
func_fd_destroy,
},
func_fd_ioctl,
};
+
+#ifdef HAVE_W32_SYSTEM
+/*
+ * Implementation of SOCKET based I/O.
+ */
+
+/* Cookie for SOCKET objects. */
+typedef struct estream_cookie_sock
+{
+ SOCKET sock; /* The SOCKET we are using for actual output. */
+ int no_close; /* If set we won't close the file descriptor. */
+ int nonblock; /* Non-blocking mode is enabled. */
+} *estream_cookie_sock_t;
+
+
+/*
+ * Create function for objects indentified by a libc file descriptor.
+ */
+static int
+func_sock_create (void **cookie, SOCKET sock,
+ unsigned int modeflags, int no_close)
+{
+ estream_cookie_sock_t sock_cookie;
+ int err;
+
+ trace (("enter: sock=%d mf=%x nc=%d", (int)sock, modeflags, no_close));
+
+ sock_cookie = mem_alloc (sizeof (*sock_cookie));
+ if (! sock_cookie)
+ err = -1;
+ else
+ {
+ sock_cookie->sock = sock;
+ sock_cookie->no_close = no_close;
+ sock_cookie->nonblock = !!(modeflags & O_NONBLOCK);
+ *cookie = sock_cookie;
+ err = 0;
+ }
+
+ trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err));
+ return err;
+}
+
+
+/*
+ * Read function for SOCKET objects.
+ */
+static gpgrt_ssize_t
+func_sock_read (void *cookie, void *buffer, size_t size)
+
+{
+ estream_cookie_sock_t file_cookie = cookie;
+ gpgrt_ssize_t bytes_read;
+
+ trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
+
+ if (!size)
+ bytes_read = -1; /* We don't know whether anything is pending. */
+ else if (IS_INVALID_FD (file_cookie->sock))
+ {
+ _gpgrt_yield ();
+ bytes_read = 0;
+ }
+ else
+ {
+ _gpgrt_pre_syscall ();
+ do
+ {
+ bytes_read = recv (file_cookie->sock, buffer, size, 0);
+ }
+ while (bytes_read == -1 && errno == EINTR);
+ _gpgrt_post_syscall ();
+ }
+ trace_errno (bytes_read == -1, ("leave: bytes_read=%d", (int)bytes_read));
+ return bytes_read;
+}
+
+
+/*
+ * Write function for SOCKET objects.
+ */
+static gpgrt_ssize_t
+func_sock_write (void *cookie, const void *buffer, size_t size)
+{
+ estream_cookie_sock_t file_cookie = cookie;
+ gpgrt_ssize_t bytes_written;
+
+ trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
+
+ if (IS_INVALID_FD (file_cookie->sock))
+ {
+ _gpgrt_yield ();
+ bytes_written = size; /* Yeah: Success writing to the bit bucket. */
+ }
+ else if (buffer)
+ {
+ _gpgrt_pre_syscall ();
+ do
+ {
+ bytes_written = send (file_cookie->sock, buffer, size, 0);
+ }
+ while (bytes_written == -1 && errno == EINTR);
+ _gpgrt_post_syscall ();
+ }
+ else
+ bytes_written = size; /* Note that for a flush SIZE should be 0. */
+
+ trace_errno (bytes_written == -1,
+ ("leave: bytes_written=%d", (int)bytes_written));
+ return bytes_written;
+}
+
+
+/*
+ * Seek function for SOCKET objects.
+ */
+static int
+func_sock_seek (void *cookie, gpgrt_off_t *offset, int whence)
+{
+ (void)cookie;
+ (void)offset;
+ (void)whence;
+ _set_errno (ESPIPE);
+ return -1;
+}
+
+
+/*
+ * The IOCTL function for SOCKET objects.
+ */
+static int
+func_sock_ioctl (void *cookie, int cmd, void *ptr, size_t *len)
+{
+ estream_cookie_sock_t sock_cookie = cookie;
+ int ret;
+
+ if (cmd == COOKIE_IOCTL_NONBLOCK && !len)
+ {
+ sock_cookie->nonblock = !!ptr;
+ if (IS_INVALID_FD (sock_cookie->sock))
+ {
+ _set_errno (EINVAL);
+ ret = -1;
+ }
+ else
+ {
+ u_long mode = 0;
+
+ if (sock_cookie->nonblock)
+ mode = 1;
+
+ ret = ioctlsocket (sock_cookie->sock, FIONBIO, &mode);
+ }
+ }
+ else
+ {
+ _set_errno (EINVAL);
+ ret = -1;
+ }
+
+ return ret;
+}
+
+/*
+ * The destroy function for SOCKET objects.
+ */
+static int
+func_sock_destroy (void *cookie)
+{
+ estream_cookie_sock_t sock_cookie = cookie;
+ int err;
+
+ trace (("enter: cookie=%p", cookie));
+
+ if (sock_cookie)
+ {
+ if (IS_INVALID_FD (sock_cookie->sock))
+ err = 0;
+ else
+ err = sock_cookie->no_close? 0 : closesocket (sock_cookie->sock);
+ mem_free (sock_cookie);
+ }
+ else
+ err = 0;
+
+ trace_errno (err,("leave: err=%d", err));
+ return err;
+}
+
+
+/*
+ * Access object for the fd functions.
+ */
+static struct cookie_io_functions_s estream_functions_sock =
+ {
+ {
+ func_sock_read,
+ func_sock_write,
+ func_sock_seek,
+ func_sock_destroy,
+ },
+ func_sock_ioctl,
+ };
/*
* Implementation of W32 handle based I/O.
*/
-#ifdef HAVE_W32_SYSTEM
/* Cookie for fd objects. */
typedef struct estream_cookie_w32
{
HANDLE hd; /* The handle we are using for actual output. */
int no_close; /* If set we won't close the handle. */
int no_syscall_clamp; /* Do not use the syscall clamp. */
} *estream_cookie_w32_t;
/*
* Create function for w32 handle objects.
*/
static int
func_w32_create (void **cookie, HANDLE hd,
unsigned int modeflags, int no_close, int no_syscall_clamp)
{
estream_cookie_w32_t w32_cookie;
int err;
trace (("enter: hd=%p mf=%x nc=%d nsc=%d",
hd, modeflags, no_close, no_syscall_clamp));
w32_cookie = mem_alloc (sizeof (*w32_cookie));
if (!w32_cookie)
err = -1;
else
{
/* CR/LF translations are not supported when using the bare W32
API. If that is really required we need to implemented that
in the upper layer. */
(void)modeflags;
w32_cookie->hd = hd;
w32_cookie->no_close = no_close;
w32_cookie->no_syscall_clamp = no_syscall_clamp;
*cookie = w32_cookie;
err = 0;
}
trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err));
return err;
}
/*
* Read function for W32 handle objects.
*
* Note that this function may also be used by the reader thread of
* w32-stream. In that case the NO_SYSCALL_CLAMP is set.
*/
static gpgrt_ssize_t
func_w32_read (void *cookie, void *buffer, size_t size)
{
estream_cookie_w32_t w32_cookie = cookie;
gpgrt_ssize_t bytes_read;
trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
if (!size)
bytes_read = -1; /* We don't know whether anything is pending. */
else if (w32_cookie->hd == INVALID_HANDLE_VALUE)
{
_gpgrt_yield ();
bytes_read = 0;
}
else
{
if (!w32_cookie->no_syscall_clamp)
_gpgrt_pre_syscall ();
do
{
DWORD nread, ec;
trace (("cookie=%p calling ReadFile", cookie));
if (!ReadFile (w32_cookie->hd, buffer, size, &nread, NULL))
{
ec = GetLastError ();
trace (("cookie=%p ReadFile failed: ec=%ld", cookie,ec));
if (ec == ERROR_BROKEN_PIPE)
bytes_read = 0; /* Like our pth_read we handle this as EOF. */
else
{
_set_errno (map_w32_to_errno (ec));
bytes_read = -1;
}
}
else
bytes_read = (int)nread;
}
while (bytes_read == -1 && errno == EINTR);
if (!w32_cookie->no_syscall_clamp)
_gpgrt_post_syscall ();
}
trace_errno (bytes_read==-1,("leave: bytes_read=%d", (int)bytes_read));
return bytes_read;
}
/*
* Write function for W32 handle objects.
*
* Note that this function may also be used by the writer thread of
* w32-stream. In that case the NO_SYSCALL_CLAMP is set.
*/
static gpgrt_ssize_t
func_w32_write (void *cookie, const void *buffer, size_t size)
{
estream_cookie_w32_t w32_cookie = cookie;
gpgrt_ssize_t bytes_written;
trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size));
if (w32_cookie->hd == INVALID_HANDLE_VALUE)
{
_gpgrt_yield ();
bytes_written = size; /* Yeah: Success writing to the bit bucket. */
}
else if (buffer)
{
if (!w32_cookie->no_syscall_clamp)
_gpgrt_pre_syscall ();
do
{
DWORD nwritten;
trace (("cookie=%p calling WriteFile", cookie));
if (!WriteFile (w32_cookie->hd, buffer, size, &nwritten, NULL))
{
DWORD ec = GetLastError ();
trace (("cookie=%p WriteFile failed: ec=%ld", cookie, ec));
_set_errno (map_w32_to_errno (ec));
bytes_written = -1;
}
else
bytes_written = (int)nwritten;
}
while (bytes_written == -1 && errno == EINTR);
if (!w32_cookie->no_syscall_clamp)
_gpgrt_post_syscall ();
}
else
bytes_written = size; /* Note that for a flush SIZE should be 0. */
trace_errno (bytes_written==-1,
("leave: bytes_written=%d", (int)bytes_written));
return bytes_written;
}
/*
* Seek function for W32 handle objects.
*/
static int
func_w32_seek (void *cookie, gpgrt_off_t *offset, int whence)
{
estream_cookie_w32_t w32_cookie = cookie;
DWORD method;
LARGE_INTEGER distance, newoff;
if (w32_cookie->hd == INVALID_HANDLE_VALUE)
{
_set_errno (ESPIPE);
return -1;
}
if (whence == SEEK_SET)
{
method = FILE_BEGIN;
distance.QuadPart = (unsigned long long)(*offset);
}
else if (whence == SEEK_CUR)
{
method = FILE_CURRENT;
distance.QuadPart = (long long)(*offset);
}
else if (whence == SEEK_END)
{
method = FILE_END;
distance.QuadPart = (long long)(*offset);
}
else
{
_set_errno (EINVAL);
return -1;
}
#ifdef HAVE_W32CE_SYSTEM
# warning need to use SetFilePointer
#else
if (!w32_cookie->no_syscall_clamp)
_gpgrt_pre_syscall ();
if (!SetFilePointerEx (w32_cookie->hd, distance, &newoff, method))
{
_set_errno (map_w32_to_errno (GetLastError ()));
_gpgrt_post_syscall ();
return -1;
}
if (!w32_cookie->no_syscall_clamp)
_gpgrt_post_syscall ();
#endif
/* Note that gpgrt_off_t is always 64 bit. */
*offset = (gpgrt_off_t)newoff.QuadPart;
return 0;
}
/*
* Destroy function for W32 handle objects.
*/
static int
func_w32_destroy (void *cookie)
{
estream_cookie_w32_t w32_cookie = cookie;
int err;
trace (("enter: cookie=%p", cookie));
if (w32_cookie)
{
if (w32_cookie->hd == INVALID_HANDLE_VALUE)
err = 0;
else if (w32_cookie->no_close)
err = 0;
else
{
trace (("cookie=%p closing handle %p", cookie, w32_cookie->hd));
if (!CloseHandle (w32_cookie->hd))
{
DWORD ec = GetLastError ();
trace (("cookie=%p CloseHandle failed: ec=%ld", cookie,ec));
_set_errno (map_w32_to_errno (ec));
err = -1;
}
else
err = 0;
}
mem_free (w32_cookie);
}
else
err = 0;
trace_errno (err, ("leave: err=%d", err));
return err;
}
/*
* Access object for the W32 handle based objects.
*/
static struct cookie_io_functions_s estream_functions_w32 =
{
{
func_w32_read,
func_w32_write,
func_w32_seek,
func_w32_destroy,
},
NULL,
};
#endif /*HAVE_W32_SYSTEM*/
/*
* Implementation of stdio based I/O.
*/
/* Cookie for fp objects. */
typedef struct estream_cookie_fp
{
FILE *fp; /* The file pointer we are using for actual output. */
int no_close; /* If set we won't close the file pointer. */
} *estream_cookie_fp_t;
/*
* Create function for stdio based objects.
*/
static int
func_fp_create (void **cookie, FILE *fp,
unsigned int modeflags, int no_close)
{
estream_cookie_fp_t fp_cookie;
int err;
fp_cookie = mem_alloc (sizeof *fp_cookie);
if (!fp_cookie)
err = -1;
else
{
#ifdef HAVE_DOSISH_SYSTEM
/* Make sure it is in binary mode if requested. */
if ( (modeflags & O_BINARY) )
setmode (fileno (fp), O_BINARY);
#else
(void)modeflags;
#endif
fp_cookie->fp = fp;
fp_cookie->no_close = no_close;
*cookie = fp_cookie;
err = 0;
}
return err;
}
/*
* Read function for stdio based objects.
*/
static gpgrt_ssize_t
func_fp_read (void *cookie, void *buffer, size_t size)
{
estream_cookie_fp_t file_cookie = cookie;
gpgrt_ssize_t bytes_read;
if (!size)
return -1; /* We don't know whether anything is pending. */
if (file_cookie->fp)
{
_gpgrt_pre_syscall ();
bytes_read = fread (buffer, 1, size, file_cookie->fp);
_gpgrt_post_syscall ();
}
else
bytes_read = 0;
if (!bytes_read && ferror (file_cookie->fp))
return -1;
return bytes_read;
}
/*
* Write function for stdio bases objects.
*/
static gpgrt_ssize_t
func_fp_write (void *cookie, const void *buffer, size_t size)
{
estream_cookie_fp_t file_cookie = cookie;
size_t bytes_written;
if (file_cookie->fp)
{
_gpgrt_pre_syscall ();
if (buffer)
{
#ifdef HAVE_W32_SYSTEM
/* Using an fwrite to stdout connected to the console fails
with the error "Not enough space" for an fwrite size of
>= 52KB (tested on Windows XP SP2). To solve this we
always chunk the writes up into smaller blocks. */
bytes_written = 0;
while (bytes_written < size)
{
size_t cnt = size - bytes_written;
if (cnt > 32*1024)
cnt = 32*1024;
if (fwrite ((const char*)buffer + bytes_written,
cnt, 1, file_cookie->fp) != 1)
break; /* Write error. */
bytes_written += cnt;
}
#else
bytes_written = fwrite (buffer, 1, size, file_cookie->fp);
#endif
}
else /* Only flush requested. */
bytes_written = size;
fflush (file_cookie->fp);
_gpgrt_post_syscall ();
}
else
bytes_written = size; /* Successfully written to the bit bucket. */
if (bytes_written != size)
return -1;
return bytes_written;
}
/*
* Seek function for stdio based objects.
*/
static int
func_fp_seek (void *cookie, gpgrt_off_t *offset, int whence)
{
estream_cookie_fp_t file_cookie = cookie;
long int offset_new;
if (!file_cookie->fp)
{
_set_errno (ESPIPE);
return -1;
}
_gpgrt_pre_syscall ();
if ( fseek (file_cookie->fp, (long int)*offset, whence) )
{
/* fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", */
/* errno,strerror (errno)); */
_gpgrt_post_syscall ();
return -1;
}
offset_new = ftell (file_cookie->fp);
_gpgrt_post_syscall ();
if (offset_new == -1)
{
/* fprintf (stderr, "\nftell failed: errno=%d (%s)\n", */
/* errno,strerror (errno)); */
return -1;
}
*offset = offset_new;
return 0;
}
/*
* Destroy function for stdio based objects.
*/
static int
func_fp_destroy (void *cookie)
{
estream_cookie_fp_t fp_cookie = cookie;
int err;
if (fp_cookie)
{
if (fp_cookie->fp)
{
_gpgrt_pre_syscall ();
fflush (fp_cookie->fp);
_gpgrt_post_syscall ();
err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp);
}
else
err = 0;
mem_free (fp_cookie);
}
else
err = 0;
return err;
}
/*
* Access object for stdio based objects.
*/
static struct cookie_io_functions_s estream_functions_fp =
{
{
func_fp_read,
func_fp_write,
func_fp_seek,
func_fp_destroy,
},
NULL,
};
/*
* Implementation of file name based I/O.
*
* Note that only a create function is required because the other
* operations ares handled by file descriptor based I/O.
*/
#ifdef HAVE_W32_SYSTEM
static int
any8bitchar (const char *string)
{
if (string)
for ( ; *string; string++)
if ((*string & 0x80))
return 1;
return 0;
}
#endif /*HAVE_W32_SYSTEM*/
/* Create function for objects identified by a file name. */
static int
func_file_create (void **cookie, int *filedes,
const char *path, unsigned int modeflags, unsigned int cmode)
{
estream_cookie_fd_t file_cookie;
int err;
int fd;
err = 0;
file_cookie = mem_alloc (sizeof (*file_cookie));
if (! file_cookie)
{
err = -1;
goto out;
}
#ifdef HAVE_W32_SYSTEM
if (any8bitchar (path))
{
wchar_t *wpath;
wpath = _gpgrt_utf8_to_wchar (path);
if (!wpath)
fd = -1;
else
{
fd = _wopen (wpath, modeflags, cmode);
_gpgrt_free_wchar (wpath);
}
}
else /* Avoid unnecessary conversion. */
fd = open (path, modeflags, cmode);
#else
fd = open (path, modeflags, cmode);
#endif
if (fd == -1)
{
err = -1;
goto out;
}
#ifdef HAVE_DOSISH_SYSTEM
/* Make sure it is in binary mode if requested. */
if ( (modeflags & O_BINARY) )
setmode (fd, O_BINARY);
#endif
file_cookie->fd = fd;
file_cookie->no_close = 0;
*cookie = file_cookie;
*filedes = fd;
out:
if (err)
mem_free (file_cookie);
return err;
}
/* Create function for objects identified by a file name. Windows
* version to use CreateFile. */
#ifdef HAVE_W32_SYSTEM
static int
func_file_create_w32 (void **cookie, HANDLE *rethd, const char *path,
unsigned int modeflags, unsigned int cmode)
{
estream_cookie_w32_t hd_cookie;
wchar_t *wpath = NULL;
int err = 0;
HANDLE hd;
DWORD desired_access;
DWORD share_mode;
DWORD creation_distribution;
(void)cmode;
hd_cookie = mem_alloc (sizeof *hd_cookie);
if (!hd_cookie)
{
err = -1;
goto leave;
}
wpath = _gpgrt_fname_to_wchar (path);
if (!wpath)
{
err = -1;
goto leave;
}
if ((modeflags & O_WRONLY))
{
desired_access = GENERIC_WRITE;
share_mode = FILE_SHARE_WRITE;
}
else if ((modeflags & O_RDWR))
{
desired_access = GENERIC_READ | GENERIC_WRITE;
share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
}
else
{
desired_access = GENERIC_READ;
share_mode = FILE_SHARE_READ;
}
creation_distribution = 0;
if ((modeflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
creation_distribution |= CREATE_NEW;
else if ((modeflags & O_TRUNC) == O_TRUNC)
{
if ((modeflags & O_CREAT) == O_CREAT)
creation_distribution |= CREATE_ALWAYS;
else if ((modeflags & O_RDONLY) != O_RDONLY)
creation_distribution |= TRUNCATE_EXISTING;
}
else if ((modeflags & O_APPEND) == O_APPEND)
creation_distribution |= OPEN_EXISTING;
else if ((modeflags & O_CREAT) == O_CREAT)
creation_distribution |= OPEN_ALWAYS;
else
creation_distribution |= OPEN_EXISTING;
hd = CreateFileW (wpath,
desired_access,
share_mode,
NULL, /* security attributes */
creation_distribution,
0, /* flags and attributes */
NULL); /* template file */
if (hd == INVALID_HANDLE_VALUE)
{
_set_errno (map_w32_to_errno (GetLastError ()));
err = -1;
goto leave;
}
hd_cookie->hd = hd;
hd_cookie->no_close = 0;
hd_cookie->no_syscall_clamp = 0;
*cookie = hd_cookie;
*rethd = hd;
leave:
_gpgrt_free_wchar (wpath);
if (err)
mem_free (hd_cookie);
return err;
}
#endif /*HAVE_W32_SYSTEM*/
/* Flags used by parse_mode and friends. */
#define X_SAMETHREAD (1 << 0)
#define X_SYSOPEN (1 << 1)
#define X_POLLABLE (1 << 2)
/* Parse the mode flags of fopen et al. In addition to the POSIX
* defined mode flags keyword parameters are supported. These are
* key/value pairs delimited by comma and optional white spaces.
* Keywords and values may not contain a comma or white space; unknown
* keywords are skipped. Supported keywords are:
*
* mode=
*
* Creates a file and gives the new file read and write permissions
* for the user and read permission for the group. The format of
* the string is the same as shown by the -l option of the ls(1)
* command. However the first letter must be a dash and it is
* allowed to leave out trailing dashes. If this keyword parameter
* is not given the default mode for creating files is "-rw-rw-r--"
* (664). Note that the system still applies the current umask to
* the mode when creating a file. Example:
*
* "wb,mode=-rw-r--"
*
* samethread
*
* Assumes that the object is only used by the creating thread and
* disables any internal locking. This keyword is also found on
* IBM systems.
*
* nonblock
*
* The object is opened in non-blocking mode. This is the same as
* calling gpgrt_set_nonblock on the file.
*
* sysopen
*
* The object is opened in GPGRT_SYSHD_HANDLE mode. On POSIX this
* is a NOP but under Windows the direct W32 API functions (HANDLE)
* are used instead of their libc counterparts (fd). This flag
* also allows to use file names longer than MAXPATH. Note that
* gpgrt_fileno does not not work for such a stream under Windows.
*
* pollable
*
* The object is opened in a way suitable for use with es_poll. On
* POSIX this is a NOP but under Windows we create up to two
* threads, one for reading and one for writing, do any I/O there,
* and synchronize with them in order to support es_poll.
*
* Note: R_CMODE is optional because is only required by functions
* which are able to creat a file.
*/
static int
parse_mode (const char *modestr,
unsigned int *modeflags,
unsigned int *r_xmode,
unsigned int *r_cmode)
{
unsigned int omode, oflags, cmode;
int got_cmode = 0;
*r_xmode = 0;
switch (*modestr)
{
case 'r':
omode = O_RDONLY;
oflags = 0;
break;
case 'w':
omode = O_WRONLY;
oflags = O_TRUNC | O_CREAT;
break;
case 'a':
omode = O_WRONLY;
oflags = O_APPEND | O_CREAT;
break;
default:
_set_errno (EINVAL);
return -1;
}
for (modestr++; *modestr; modestr++)
{
switch (*modestr)
{
case '+':
omode = O_RDWR;
break;
case 'b':
oflags |= O_BINARY;
break;
case 'x':
oflags |= O_EXCL;
break;
case ',':
goto keyvalue;
default: /* Ignore unknown flags. */
break;
}
}
keyvalue:
/* Parse key/value pairs (similar to fopen on mainframes). */
for (cmode=0; *modestr == ','; modestr += strcspn (modestr, ","))
{
modestr++;
modestr += strspn (modestr, " \t");
if (!strncmp (modestr, "mode=", 5))
{
static struct {
char letter;
unsigned int value;
} table[] = { { '-', 0 },
{ 'r', S_IRUSR }, { 'w', S_IWUSR }, { 'x', S_IXUSR },
{ 'r', S_IRGRP }, { 'w', S_IWGRP }, { 'x', S_IXGRP },
{ 'r', S_IROTH }, { 'w', S_IWOTH }, { 'x', S_IXOTH }};
int idx;
got_cmode = 1;
modestr += 5;
/* For now we only support a string as used by ls(1) and no
octal numbers. The first character must be a dash. */
for (idx=0; idx < 10 && *modestr; idx++, modestr++)
{
if (*modestr == table[idx].letter)
cmode |= table[idx].value;
else if (*modestr != '-')
break;
}
if (*modestr && !strchr (" \t,", *modestr))
{
_set_errno (EINVAL);
return -1;
}
}
else if (!strncmp (modestr, "samethread", 10))
{
modestr += 10;
if (*modestr && !strchr (" \t,", *modestr))
{
_set_errno (EINVAL);
return -1;
}
*r_xmode |= X_SAMETHREAD;
}
else if (!strncmp (modestr, "nonblock", 8))
{
modestr += 8;
if (*modestr && !strchr (" \t,", *modestr))
{
_set_errno (EINVAL);
return -1;
}
oflags |= O_NONBLOCK;
#if HAVE_W32_SYSTEM
/* Currently, nonblock implies pollable on Windows. */
*r_xmode |= X_POLLABLE;
#endif
}
else if (!strncmp (modestr, "sysopen", 7))
{
modestr += 7;
if (*modestr && !strchr (" \t,", *modestr))
{
_set_errno (EINVAL);
return -1;
}
*r_xmode |= X_SYSOPEN;
}
else if (!strncmp (modestr, "pollable", 8))
{
modestr += 8;
if (*modestr && !strchr (" \t,", *modestr))
{
_set_errno (EINVAL);
return -1;
}
*r_xmode |= X_POLLABLE;
}
}
if (!got_cmode)
cmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
*modeflags = (omode | oflags);
if (r_cmode)
*r_cmode = cmode;
return 0;
}
/*
* Low level stream functionality.
*/
static int
fill_stream (estream_t stream)
{
size_t bytes_read = 0;
int err;
if (!stream->intern->func_read)
{
_set_errno (EOPNOTSUPP);
err = -1;
}
else if (!stream->buffer_size)
err = 0;
else
{
gpgrt_cookie_read_function_t func_read = stream->intern->func_read;
gpgrt_ssize_t ret;
ret = (*func_read) (stream->intern->cookie,
stream->buffer, stream->buffer_size);
if (ret == -1)
{
bytes_read = 0;
err = -1;
#if EWOULDBLOCK != EAGAIN
if (errno == EWOULDBLOCK)
_set_errno (EAGAIN);
#endif
}
else
{
bytes_read = ret;
err = 0;
}
}
if (err)
{
if (errno != EAGAIN)
{
if (errno == EPIPE)
stream->intern->indicators.hup = 1;
stream->intern->indicators.err = 1;
}
}
else if (!bytes_read)
stream->intern->indicators.eof = 1;
stream->intern->offset += stream->data_len;
stream->data_len = bytes_read;
stream->data_offset = 0;
return err;
}
static int
flush_stream (estream_t stream)
{
gpgrt_cookie_write_function_t func_write = stream->intern->func_write;
int err;
gpgrt_assert (stream->flags.writing);
if (stream->data_offset)
{
size_t bytes_written;
size_t data_flushed;
gpgrt_ssize_t ret;
if (! func_write)
{
_set_errno (EOPNOTSUPP);
err = -1;
goto out;
}
/* Note: to prevent an endless loop caused by user-provided
write-functions that pretend to have written more bytes than
they were asked to write, we have to check for
"(stream->data_offset - data_flushed) > 0" instead of
"stream->data_offset - data_flushed". */
data_flushed = 0;
err = 0;
while ((((gpgrt_ssize_t) (stream->data_offset - data_flushed)) > 0)
&& !err)
{
ret = (*func_write) (stream->intern->cookie,
stream->buffer + data_flushed,
stream->data_offset - data_flushed);
if (ret == -1)
{
bytes_written = 0;
err = -1;
#if EWOULDBLOCK != EAGAIN
if (errno == EWOULDBLOCK)
_set_errno (EAGAIN);
#endif
}
else
bytes_written = ret;
data_flushed += bytes_written;
if (err)
break;
}
stream->data_flushed += data_flushed;
if (stream->data_offset == data_flushed)
{
stream->intern->offset += stream->data_offset;
stream->data_offset = 0;
stream->data_flushed = 0;
}
}
else
err = 0;
/* Always propagate flush event in case gpgrt_fflush was called
* explictly to do flush buffers in caller's cookie functions. */
(*func_write) (stream->intern->cookie, NULL, 0);
out:
if (err && errno != EAGAIN)
{
if (errno == EPIPE)
stream->intern->indicators.hup = 1;
stream->intern->indicators.err = 1;
}
return err;
}
/*
* Discard buffered data for STREAM.
*/
static void
es_empty (estream_t stream)
{
gpgrt_assert (!stream->flags.writing);
stream->data_len = 0;
stream->data_offset = 0;
stream->unread_data_len = 0;
}
/*
* Initialize STREAM.
*/
static void
init_stream_obj (estream_t stream,
void *cookie, es_syshd_t *syshd,
gpgrt_stream_backend_kind_t kind,
struct cookie_io_functions_s functions,
unsigned int modeflags, unsigned int xmode)
{
stream->intern->kind = kind;
stream->intern->cookie = cookie;
stream->intern->opaque = NULL;
stream->intern->offset = 0;
stream->intern->func_read = functions.public.func_read;
stream->intern->func_write = functions.public.func_write;
stream->intern->func_seek = functions.public.func_seek;
stream->intern->func_ioctl = functions.func_ioctl;
stream->intern->func_close = functions.public.func_close;
stream->intern->strategy = _IOFBF;
stream->intern->syshd = *syshd;
stream->intern->print_ntotal = 0;
stream->intern->indicators.err = 0;
stream->intern->indicators.eof = 0;
stream->intern->indicators.hup = 0;
stream->intern->is_stdstream = 0;
stream->intern->stdstream_fd = 0;
stream->intern->deallocate_buffer = 0;
stream->intern->printable_fname = NULL;
stream->intern->printable_fname_inuse = 0;
stream->intern->samethread = !! (xmode & X_SAMETHREAD);
stream->intern->onclose = NULL;
stream->data_len = 0;
stream->data_offset = 0;
stream->data_flushed = 0;
stream->unread_data_len = 0;
/* Depending on the modeflags we set whether we start in writing or
reading mode. This is required in case we are working on a
stream which is not seeekable (like stdout). Without this
pre-initialization we would do a seek at the first write call and
as this will fail no output will be delivered. */
if ((modeflags & O_WRONLY) || (modeflags & O_RDWR) )
stream->flags.writing = 1;
else
stream->flags.writing = 0;
}
/*
* Deinitialize the STREAM object. This does _not_ free the memory,
* destroys the lock, or closes the underlying descriptor.
*/
static int
deinit_stream_obj (estream_t stream)
{
gpgrt_cookie_close_function_t func_close;
int err, tmp_err;
trace (("enter: stream %p", stream));
func_close = stream->intern->func_close;
err = 0;
if (stream->flags.writing)
{
tmp_err = flush_stream (stream);
if (!err)
err = tmp_err;
}
if (func_close)
{
trace (("stream %p calling func_close", stream));
tmp_err = func_close (stream->intern->cookie);
if (!err)
err = tmp_err;
}
mem_free (stream->intern->printable_fname);
stream->intern->printable_fname = NULL;
stream->intern->printable_fname_inuse = 0;
while (stream->intern->onclose)
{
notify_list_t tmp = stream->intern->onclose->next;
mem_free (stream->intern->onclose);
stream->intern->onclose = tmp;
}
trace_errno (err, ("leave: stream %p err=%d", stream, err));
return err;
}
/*
* Create a new stream and initialize it. On success the new stream
* handle is stored at R_STREAM. On failure NULL is stored at
* R_STREAM.
*/
static int
create_stream (estream_t *r_stream, void *cookie, es_syshd_t *syshd,
gpgrt_stream_backend_kind_t kind,
struct cookie_io_functions_s functions, unsigned int modeflags,
unsigned int xmode, int with_locked_list)
{
estream_internal_t stream_internal_new;
estream_t stream_new;
int err;
#if HAVE_W32_SYSTEM
void *old_cookie = NULL;
#endif
stream_new = NULL;
stream_internal_new = NULL;
#if HAVE_W32_SYSTEM
if ((xmode & X_POLLABLE) && kind != BACKEND_W32)
{
/* We require the W32 backend, because only that allows us to
* write directly using the native W32 API and to disable the
* system clamp. Note that func_w32_create has already been
* called with the flag to disable the system call clamp. */
_set_errno (EINVAL);
err = -1;
goto out;
}
#endif /*HAVE_W32_SYSTEM*/
stream_new = mem_alloc (sizeof (*stream_new));
if (! stream_new)
{
err = -1;
goto out;
}
stream_internal_new = mem_alloc (sizeof (*stream_internal_new));
if (! stream_internal_new)
{
err = -1;
goto out;
}
stream_new->buffer = stream_internal_new->buffer;
stream_new->buffer_size = sizeof (stream_internal_new->buffer);
stream_new->unread_buffer = stream_internal_new->unread_buffer;
stream_new->unread_buffer_size = sizeof (stream_internal_new->unread_buffer);
stream_new->intern = stream_internal_new;
#if HAVE_W32_SYSTEM
if ((xmode & X_POLLABLE))
{
void *new_cookie;
err = _gpgrt_w32_pollable_create (&new_cookie, modeflags,
functions, cookie);
if (err)
goto out;
modeflags &= ~O_NONBLOCK;
old_cookie = cookie;
cookie = new_cookie;
kind = BACKEND_W32_POLLABLE;
functions = _gpgrt_functions_w32_pollable;
}
#endif /*HAVE_W32_SYSTEM*/
init_stream_obj (stream_new, cookie, syshd, kind, functions, modeflags,
xmode);
init_stream_lock (stream_new);
err = do_list_add (stream_new, with_locked_list);
if (err)
goto out;
*r_stream = stream_new;
out:
if (err)
{
trace_errno (err, ("leave: err=%d", err));
if (stream_new)
{
deinit_stream_obj (stream_new);
destroy_stream_lock (stream_new);
mem_free (stream_new->intern);
mem_free (stream_new);
}
}
#if HAVE_W32_SYSTEM
else if (old_cookie)
trace (("leave: success stream=%p cookie=%p,%p",
*r_stream, old_cookie, cookie));
#endif
else
trace (("leave: success stream=%p cookie=%p", *r_stream, cookie));
return err;
}
/*
* Deinitialize a stream object and destroy it. With CANCEL_MODE set
* try to cancel as much as possible (see _gpgrt_fcancel).
*/
static int
do_close (estream_t stream, int cancel_mode, int with_locked_list)
{
int err;
trace (("stream %p %s", stream, with_locked_list? "(with locked list)":""));
if (stream)
{
do_list_remove (stream, with_locked_list);
if (cancel_mode)
{
stream->flags.writing = 0;
es_empty (stream);
}
while (stream->intern->onclose)
{
notify_list_t tmp = stream->intern->onclose->next;
if (stream->intern->onclose->fnc)
stream->intern->onclose->fnc (stream,
stream->intern->onclose->fnc_value);
mem_free (stream->intern->onclose);
stream->intern->onclose = tmp;
}
err = deinit_stream_obj (stream);
destroy_stream_lock (stream);
if (stream->intern->deallocate_buffer)
mem_free (stream->buffer);
mem_free (stream->intern);
mem_free (stream);
}
else
err = 0;
trace_errno (err, ("stream %p err=%d", stream, err));
return err;
}
/*
* The onclose worker function which is called with a locked
* stream.
*/
static int
do_onclose (estream_t stream, int mode,
void (*fnc) (estream_t, void*), void *fnc_value)
{
notify_list_t item;
if (!mode)
{
for (item = stream->intern->onclose; item; item = item->next)
if (item->fnc && item->fnc == fnc && item->fnc_value == fnc_value)
item->fnc = NULL; /* Disable this notification. */
}
else
{
item = mem_alloc (sizeof *item);
if (!item)
return -1;
item->fnc = fnc;
item->fnc_value = fnc_value;
item->next = stream->intern->onclose;
stream->intern->onclose = item;
}
return 0;
}
/*
* Try to read BYTES_TO_READ bytes from STREAM into BUFFER in
* unbuffered-mode, storing the amount of bytes read at BYTES_READ.
*/
static int
do_read_nbf (estream_t _GPGRT__RESTRICT stream,
unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read)
{
gpgrt_cookie_read_function_t func_read = stream->intern->func_read;
size_t data_read;
gpgrt_ssize_t ret;
int err;
data_read = 0;
err = 0;
while (bytes_to_read - data_read)
{
ret = (*func_read) (stream->intern->cookie,
buffer + data_read, bytes_to_read - data_read);
if (ret == -1)
{
err = -1;
#if EWOULDBLOCK != EAGAIN
if (errno == EWOULDBLOCK)
_set_errno (EAGAIN);
#endif
break;
}
else if (ret)
data_read += ret;
else
break;
}
stream->intern->offset += data_read;
*bytes_read = data_read;
return err;
}
/*
* Helper for check_pending.
*/
static int
check_pending_nbf (estream_t _GPGRT__RESTRICT stream)
{
gpgrt_cookie_read_function_t func_read = stream->intern->func_read;
char buffer[1];
if (!(*func_read) (stream->intern->cookie, buffer, 0))
return 1; /* Pending bytes. */
return 0; /* No pending bytes or error. */
}
/*
* Try to read BYTES_TO_READ bytes from STREAM into BUFFER in
* fully-buffered-mode, storing the amount of bytes read at
* BYTES_READ.
*/
static int
do_read_fbf (estream_t _GPGRT__RESTRICT stream,
unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read)
{
size_t data_available;
size_t data_to_read;
size_t data_read;
int err;
data_read = 0;
err = 0;
while ((bytes_to_read - data_read) && (! err))
{
if (stream->data_offset == stream->data_len)
{
/* Nothing more to read in current container, try to
fill container with new data. */
err = fill_stream (stream);
if (! err)
if (! stream->data_len)
/* Filling did not result in any data read. */
break;
}
if (! err)
{
/* Filling resulted in some new data. */
data_to_read = bytes_to_read - data_read;
data_available = stream->data_len - stream->data_offset;
if (data_to_read > data_available)
data_to_read = data_available;
memcpy (buffer + data_read,
stream->buffer + stream->data_offset, data_to_read);
stream->data_offset += data_to_read;
data_read += data_to_read;
}
}
*bytes_read = data_read;
return err;
}
/*
* Helper for check_pending.
*/
static int
check_pending_fbf (estream_t _GPGRT__RESTRICT stream)
{
gpgrt_cookie_read_function_t func_read = stream->intern->func_read;
char buffer[1];
if (stream->data_offset == stream->data_len)
{
/* Nothing more to read in current container, check whether it
would be possible to fill the container with new data. */
if (!(*func_read) (stream->intern->cookie, buffer, 0))
return 1; /* Pending bytes. */
}
else
return 1;
return 0;
}
/*
* Try to read BYTES_TO_READ bytes from STREAM into BUFFER in
* line-buffered-mode, storing the amount of bytes read at BYTES_READ.
*/
static int
do_read_lbf (estream_t _GPGRT__RESTRICT stream,
unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read)
{
int err;
err = do_read_fbf (stream, buffer, bytes_to_read, bytes_read);
return err;
}
/*
* Try to read BYTES_TO_READ bytes from STREAM into BUFFER, storing
* the amount of bytes read at BYTES_READ.
*/
static int
es_readn (estream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT buffer_arg,
size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read)
{
unsigned char *buffer = (unsigned char *)buffer_arg;
size_t data_read_unread, data_read;
int err;
data_read_unread = 0;
data_read = 0;
err = 0;
if (stream->flags.writing)
{
/* Switching to reading mode -> flush output. */
err = flush_stream (stream);
if (err)
goto out;
stream->flags.writing = 0;
}
/* Read unread data first. */
while ((bytes_to_read - data_read_unread) && stream->unread_data_len)
{
buffer[data_read_unread]
= stream->unread_buffer[stream->unread_data_len - 1];
stream->unread_data_len--;
data_read_unread++;
}
switch (stream->intern->strategy)
{
case _IONBF:
err = do_read_nbf (stream,
buffer + data_read_unread,
bytes_to_read - data_read_unread, &data_read);
break;
case _IOLBF:
err = do_read_lbf (stream,
buffer + data_read_unread,
bytes_to_read - data_read_unread, &data_read);
break;
case _IOFBF:
err = do_read_fbf (stream,
buffer + data_read_unread,
bytes_to_read - data_read_unread, &data_read);
break;
}
out:
if (bytes_read)
*bytes_read = data_read_unread + data_read;
return err;
}
/*
* Return true if at least one byte is pending for read. This is a
* best effort check and it it possible that bytes are still pending
* even if false is returned. If the stream is in writing mode it is
* switched to read mode.
*/
static int
check_pending (estream_t _GPGRT__RESTRICT stream)
{
if (stream->flags.writing)
{
/* Switching to reading mode -> flush output. */
if (flush_stream (stream))
return 0; /* Better return 0 on error. */
stream->flags.writing = 0;
}
/* Check unread data first. */
if (stream->unread_data_len)
return 1;
switch (stream->intern->strategy)
{
case _IONBF:
return check_pending_nbf (stream);
case _IOLBF:
case _IOFBF:
return check_pending_fbf (stream);
}
return 0;
}
/*
* Try to unread DATA_N bytes from DATA into STREAM, storing the
* amount of bytes successfully unread at BYTES_UNREAD.
*/
static void
es_unreadn (estream_t _GPGRT__RESTRICT stream,
const unsigned char *_GPGRT__RESTRICT data, size_t data_n,
size_t *_GPGRT__RESTRICT bytes_unread)
{
size_t space_left;
space_left = stream->unread_buffer_size - stream->unread_data_len;
if (data_n > space_left)
data_n = space_left;
if (! data_n)
goto out;
memcpy (stream->unread_buffer + stream->unread_data_len, data, data_n);
stream->unread_data_len += data_n;
stream->intern->indicators.eof = 0;
out:
if (bytes_unread)
*bytes_unread = data_n;
}
/*
* Seek in STREAM.
*/
static int
es_seek (estream_t _GPGRT__RESTRICT stream, gpgrt_off_t offset, int whence,
gpgrt_off_t *_GPGRT__RESTRICT offset_new)
{
gpgrt_cookie_seek_function_t func_seek = stream->intern->func_seek;
int err, ret;
gpgrt_off_t off;
if (! func_seek)
{
_set_errno (EOPNOTSUPP);
err = -1;
goto out;
}
if (stream->flags.writing)
{
/* Flush data first in order to prevent flushing it to the wrong
offset. */
err = flush_stream (stream);
if (err)
goto out;
stream->flags.writing = 0;
}
off = offset;
if (whence == SEEK_CUR)
{
off = off - stream->data_len + stream->data_offset;
off -= stream->unread_data_len;
}
ret = (*func_seek) (stream->intern->cookie, &off, whence);
if (ret == -1)
{
err = -1;
#if EWOULDBLOCK != EAGAIN
if (errno == EWOULDBLOCK)
_set_errno (EAGAIN);
#endif
goto out;
}
err = 0;
es_empty (stream);
if (offset_new)
*offset_new = off;
stream->intern->indicators.eof = 0;
stream->intern->offset = off;
out:
if (err)
{
if (errno == EPIPE)
stream->intern->indicators.hup = 1;
stream->intern->indicators.err = 1;
}
return err;
}
/*
* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
* unbuffered-mode, storing the amount of bytes written at
* BYTES_WRITTEN.
*/
static int
es_write_nbf (estream_t _GPGRT__RESTRICT stream,
const unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written)
{
gpgrt_cookie_write_function_t func_write = stream->intern->func_write;
size_t data_written;
gpgrt_ssize_t ret;
int err;
if (bytes_to_write && (! func_write))
{
_set_errno (EOPNOTSUPP);
err = -1;
goto out;
}
data_written = 0;
err = 0;
while (bytes_to_write - data_written)
{
ret = (*func_write) (stream->intern->cookie,
buffer + data_written,
bytes_to_write - data_written);
if (ret == -1)
{
err = -1;
#if EWOULDBLOCK != EAGAIN
if (errno == EWOULDBLOCK)
_set_errno (EAGAIN);
#endif
break;
}
else
data_written += ret;
}
stream->intern->offset += data_written;
*bytes_written = data_written;
out:
return err;
}
/*
* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
* fully-buffered-mode, storing the amount of bytes written at
* BYTES_WRITTEN.
*/
static int
es_write_fbf (estream_t _GPGRT__RESTRICT stream,
const unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written)
{
size_t space_available;
size_t data_to_write;
size_t data_written;
int err;
data_written = 0;
err = 0;
while ((bytes_to_write - data_written) && (! err))
{
if (stream->data_offset == stream->buffer_size)
/* Container full, flush buffer. */
err = flush_stream (stream);
if (! err)
{
/* Flushing resulted in empty container. */
data_to_write = bytes_to_write - data_written;
space_available = stream->buffer_size - stream->data_offset;
if (data_to_write > space_available)
data_to_write = space_available;
memcpy (stream->buffer + stream->data_offset,
buffer + data_written, data_to_write);
stream->data_offset += data_to_write;
data_written += data_to_write;
}
}
*bytes_written = data_written;
return err;
}
/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in
line-buffered-mode, storing the amount of bytes written in
*BYTES_WRITTEN. */
static int
es_write_lbf (estream_t _GPGRT__RESTRICT stream,
const unsigned char *_GPGRT__RESTRICT buffer,
size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written)
{
size_t data_flushed = 0;
size_t data_buffered = 0;
unsigned char *nlp;
int err = 0;
nlp = memrchr (buffer, '\n', bytes_to_write);
if (nlp)
{
/* Found a newline, directly write up to (including) this
character. */
err = flush_stream (stream);
if (!err)
err = es_write_nbf (stream, buffer, nlp - buffer + 1, &data_flushed);
}
if (!err)
{
/* Write remaining data fully buffered. */
err = es_write_fbf (stream, buffer + data_flushed,
bytes_to_write - data_flushed, &data_buffered);
}
*bytes_written = data_flushed + data_buffered;
return err;
}
/* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in, storing the
amount of bytes written in BYTES_WRITTEN. */
static int
es_writen (estream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer,
size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written)
{
size_t data_written;
int err;
data_written = 0;
err = 0;
if (!stream->flags.writing)
{
/* Switching to writing mode -> discard input data and seek to
position at which reading has stopped. We can do this only
if a seek function has been registered. */
if (stream->intern->func_seek)
{
err = es_seek (stream, 0, SEEK_CUR, NULL);
if (err)
{
if (errno == ESPIPE)
err = 0;
else
goto out;
}
stream->flags.writing = 1;
}
}
switch (stream->intern->strategy)
{
case _IONBF:
err = es_write_nbf (stream, buffer, bytes_to_write, &data_written);
break;
case _IOLBF:
err = es_write_lbf (stream, buffer, bytes_to_write, &data_written);
break;
case _IOFBF:
err = es_write_fbf (stream, buffer, bytes_to_write, &data_written);
break;
}
out:
if (bytes_written)
*bytes_written = data_written;
return err;
}
static int
peek_stream (estream_t _GPGRT__RESTRICT stream,
unsigned char **_GPGRT__RESTRICT data,
size_t *_GPGRT__RESTRICT data_len)
{
int err;
if (stream->flags.writing)
{
/* Switching to reading mode -> flush output. */
err = flush_stream (stream);
if (err)
goto out;
stream->flags.writing = 0;
}
if (stream->data_offset == stream->data_len)
{
/* Refill container. */
err = fill_stream (stream);
if (err)
goto out;
}
if (data)
*data = stream->buffer + stream->data_offset;
if (data_len)
*data_len = stream->data_len - stream->data_offset;
err = 0;
out:
return err;
}
/* Skip SIZE bytes of input data contained in buffer. */
static int
skip_stream (estream_t stream, size_t size)
{
int err;
if (stream->data_offset + size > stream->data_len)
{
_set_errno (EINVAL);
err = -1;
}
else
{
stream->data_offset += size;
err = 0;
}
return err;
}
static int
doreadline (estream_t _GPGRT__RESTRICT stream, size_t max_length,
char *_GPGRT__RESTRICT *_GPGRT__RESTRICT line,
size_t *_GPGRT__RESTRICT line_length)
{
size_t line_size;
estream_t line_stream;
char *line_new;
void *line_stream_cookie;
char *newline;
unsigned char *data;
size_t data_len;
int err;
es_syshd_t syshd;
line_new = NULL;
line_stream = NULL;
line_stream_cookie = NULL;
err = func_mem_create (&line_stream_cookie, NULL, 0, 0,
BUFFER_BLOCK_SIZE, 1,
mem_realloc, mem_free,
O_RDWR,
0);
if (err)
goto out;
memset (&syshd, 0, sizeof syshd);
err = create_stream (&line_stream, line_stream_cookie,
&syshd, BACKEND_MEM,
estream_functions_mem, O_RDWR, 1, 0);
if (err)
goto out;
{
size_t space_left = max_length;
line_size = 0;
for (;;)
{
if (max_length && (space_left == 1))
break;
err = peek_stream (stream, &data, &data_len);
if (err || (! data_len))
break;
if (data_len > (space_left - 1))
data_len = space_left - 1;
newline = memchr (data, '\n', data_len);
if (newline)
{
data_len = (newline - (char *) data) + 1;
err = _gpgrt_write (line_stream, data, data_len, NULL);
if (! err)
{
/* Not needed: space_left -= data_len */
line_size += data_len;
skip_stream (stream, data_len);
break; /* endless loop */
}
}
else
{
err = _gpgrt_write (line_stream, data, data_len, NULL);
if (! err)
{
space_left -= data_len;
line_size += data_len;
skip_stream (stream, data_len);
}
}
if (err)
break;
}
}
if (err)
goto out;
/* Complete line has been written to line_stream. */
if ((max_length > 1) && (! line_size))
{
stream->intern->indicators.eof = 1;
goto out;
}
err = es_seek (line_stream, 0, SEEK_SET, NULL);
if (err)
goto out;
if (! *line)
{
line_new = mem_alloc (line_size + 1);
if (! line_new)
{
err = -1;
goto out;
}
}
else
line_new = *line;
err = _gpgrt_read (line_stream, line_new, line_size, NULL);
if (err)
goto out;
line_new[line_size] = '\0';
if (! *line)
*line = line_new;
if (line_length)
*line_length = line_size;
out:
if (line_stream)
do_close (line_stream, 0, 0);
else if (line_stream_cookie)
func_mem_destroy (line_stream_cookie);
if (err)
{
if (! *line)
mem_free (line_new);
stream->intern->indicators.err = 1;
}
return err;
}
/* Output function used by estream_format. */
static int
print_writer (void *outfncarg, const char *buf, size_t buflen)
{
estream_t stream = outfncarg;
size_t nwritten;
int rc;
nwritten = 0;
rc = es_writen (stream, buf, buflen, &nwritten);
stream->intern->print_ntotal += nwritten;
return rc;
}
/* The core of our printf function. This is called in locked state. */
static int
do_print_stream (estream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format, va_list ap)
{
int rc;
stream->intern->print_ntotal = 0;
rc = _gpgrt_estream_format (print_writer, stream, sf, sfvalue, format, ap);
if (rc)
return -1;
return (int)stream->intern->print_ntotal;
}
static int
es_set_buffering (estream_t _GPGRT__RESTRICT stream,
char *_GPGRT__RESTRICT buffer, int mode, size_t size)
{
int err;
/* Flush or empty buffer depending on mode. */
if (stream->flags.writing)
{
err = flush_stream (stream);
if (err)
goto out;
}
else
es_empty (stream);
stream->intern->indicators.eof = 0;
/* Free old buffer in case that was allocated by this function. */
if (stream->intern->deallocate_buffer)
{
stream->intern->deallocate_buffer = 0;
mem_free (stream->buffer);
stream->buffer = NULL;
}
if (mode == _IONBF)
stream->buffer_size = 0;
else
{
void *buffer_new;
if (buffer)
buffer_new = buffer;
else
{
if (!size)
size = BUFSIZ;
buffer_new = mem_alloc (size);
if (! buffer_new)
{
err = -1;
goto out;
}
}
stream->buffer = buffer_new;
stream->buffer_size = size;
if (! buffer)
stream->intern->deallocate_buffer = 1;
}
stream->intern->strategy = mode;
err = 0;
out:
return err;
}
static gpgrt_off_t
es_offset_calculate (estream_t stream)
{
gpgrt_off_t offset;
offset = stream->intern->offset + stream->data_offset;
if (offset < stream->unread_data_len)
/* Offset undefined. */
offset = 0;
else
offset -= stream->unread_data_len;
return offset;
}
static void
es_opaque_ctrl (estream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT opaque_new,
void **_GPGRT__RESTRICT opaque_old)
{
if (opaque_old)
*opaque_old = stream->intern->opaque;
if (opaque_new)
stream->intern->opaque = opaque_new;
}
/* API. */
estream_t
_gpgrt_fopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode)
{
unsigned int modeflags, cmode, xmode;
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
int err;
struct cookie_io_functions_s *functions;
es_syshd_t syshd;
int kind;
err = parse_mode (mode, &modeflags, &xmode, &cmode);
if (err)
goto leave;
/* Convenience hack so that we can use /dev/null on Windows. */
#ifdef HAVE_W32_SYSTEM
if (path && !strcmp (path, "/dev/null"))
path = "nul";
#endif
#ifdef HAVE_W32_SYSTEM
if ((xmode & X_SYSOPEN))
{
kind = BACKEND_W32;
functions = &estream_functions_w32;
syshd.type = ES_SYSHD_HANDLE;
err = func_file_create_w32 (&cookie, &syshd.u.handle,
path, modeflags, cmode);
}
else
#endif /* W32 */
{
kind = BACKEND_FD;
functions = &estream_functions_fd;
syshd.type = ES_SYSHD_FD;
err = func_file_create (&cookie, &syshd.u.fd,
path, modeflags, cmode);
}
if (err)
goto leave;
create_called = 1;
err = create_stream (&stream, cookie, &syshd, kind,
*functions, modeflags, xmode, 0);
if (err)
goto leave;
if (stream && path)
fname_set_internal (stream, path, 1);
leave:
if (err && create_called)
functions->public.func_close (cookie);
return stream;
}
/* Create a new estream object in memory. If DATA is not NULL this
buffer will be used as the memory buffer; thus after this functions
returns with the success the the memory at DATA belongs to the new
estream. The allocated length of DATA is given by DATA_LEN and its
used length by DATA_N. Usually this is malloced buffer; if a
static buffer is provided, the caller must pass false for GROW and
provide a dummy function for FUNC_FREE. FUNC_FREE and FUNC_REALLOC
allow the caller to provide custom functions for realloc and free
to be used by the new estream object. Note that the realloc
function is also used for initial allocation. If DATA is NULL a
buffer is internally allocated; either using internal function or
those provide by the caller. It is an error to provide a realloc
function but no free function. Providing only a free function is
allowed as long as GROW is false. */
estream_t
_gpgrt_mopen (void *_GPGRT__RESTRICT data, size_t data_n, size_t data_len,
unsigned int grow,
func_realloc_t func_realloc, func_free_t func_free,
const char *_GPGRT__RESTRICT mode)
{
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
unsigned int modeflags, xmode;
int err;
es_syshd_t syshd;
err = parse_mode (mode, &modeflags, &xmode, NULL);
if (err)
goto out;
err = func_mem_create (&cookie, data, data_n, data_len,
BUFFER_BLOCK_SIZE, grow,
func_realloc, func_free, modeflags, 0);
if (err)
goto out;
memset (&syshd, 0, sizeof syshd);
create_called = 1;
err = create_stream (&stream, cookie, &syshd, BACKEND_MEM,
estream_functions_mem, modeflags, xmode, 0);
out:
if (err && create_called)
(*estream_functions_mem.public.func_close) (cookie);
return stream;
}
estream_t
_gpgrt_fopenmem (size_t memlimit, const char *_GPGRT__RESTRICT mode)
{
unsigned int modeflags, xmode;
estream_t stream = NULL;
void *cookie = NULL;
es_syshd_t syshd;
/* Memory streams are always read/write. We use MODE only to get
the append flag. */
if (parse_mode (mode, &modeflags, &xmode, NULL))
return NULL;
modeflags |= O_RDWR;
if (func_mem_create (&cookie, NULL, 0, 0,
BUFFER_BLOCK_SIZE, 1,
mem_realloc, mem_free, modeflags,
memlimit))
return NULL;
memset (&syshd, 0, sizeof syshd);
if (create_stream (&stream, cookie, &syshd, BACKEND_MEM,
estream_functions_mem, modeflags, xmode, 0))
(*estream_functions_mem.public.func_close) (cookie);
return stream;
}
/* This is the same as es_fopenmem but intializes the memory with a
copy of (DATA,DATALEN). The stream is initially set to the
beginning. If MEMLIMIT is not 0 but shorter than DATALEN it
DATALEN will be used as the value for MEMLIMIT. */
estream_t
_gpgrt_fopenmem_init (size_t memlimit, const char *_GPGRT__RESTRICT mode,
const void *data, size_t datalen)
{
estream_t stream;
if (memlimit && memlimit < datalen)
memlimit = datalen;
stream = _gpgrt_fopenmem (memlimit, mode);
if (stream && data && datalen)
{
if (es_writen (stream, data, datalen, NULL))
{
int saveerrno = errno;
_gpgrt_fclose (stream);
stream = NULL;
_set_errno (saveerrno);
}
else
{
es_seek (stream, 0L, SEEK_SET, NULL);
stream->intern->indicators.eof = 0;
stream->intern->indicators.err = 0;
}
}
return stream;
}
estream_t
_gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie,
const char *_GPGRT__RESTRICT mode,
gpgrt_cookie_io_functions_t functions)
{
unsigned int modeflags, xmode;
estream_t stream;
int err;
es_syshd_t syshd;
struct cookie_io_functions_s io_functions = { functions, NULL };
stream = NULL;
modeflags = 0;
err = parse_mode (mode, &modeflags, &xmode, NULL);
if (err)
goto out;
memset (&syshd, 0, sizeof syshd);
err = create_stream (&stream, cookie, &syshd, BACKEND_USER, io_functions,
modeflags, xmode, 0);
if (err)
goto out;
out:
return stream;
}
static estream_t
do_fdopen (int filedes, const char *mode, int no_close, int with_locked_list)
{
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
unsigned int modeflags, xmode;
int err;
es_syshd_t syshd;
err = parse_mode (mode, &modeflags, &xmode, NULL);
if (err)
goto out;
if ((xmode & X_SYSOPEN))
{
/* Not allowed for fdopen. */
_set_errno (EINVAL);
err = -1;
goto out;
}
err = func_fd_create (&cookie, filedes, modeflags, no_close);
if (err)
goto out;
syshd.type = ES_SYSHD_FD;
syshd.u.fd = filedes;
create_called = 1;
err = create_stream (&stream, cookie, &syshd,
BACKEND_FD, estream_functions_fd,
modeflags, xmode, with_locked_list);
if (!err && stream)
{
if ((modeflags & O_NONBLOCK))
err = stream->intern->func_ioctl (cookie, COOKIE_IOCTL_NONBLOCK,
"", NULL);
}
out:
if (err && create_called)
(*estream_functions_fd.public.func_close) (cookie);
return stream;
}
estream_t
_gpgrt_fdopen (int filedes, const char *mode)
{
return do_fdopen (filedes, mode, 0, 0);
}
/* A variant of es_fdopen which does not close FILEDES at the end. */
estream_t
_gpgrt_fdopen_nc (int filedes, const char *mode)
{
return do_fdopen (filedes, mode, 1, 0);
}
static estream_t
do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list)
{
unsigned int modeflags, cmode, xmode;
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
int err;
es_syshd_t syshd;
err = parse_mode (mode, &modeflags, &xmode, &cmode);
if (err)
goto out;
if ((xmode & X_SYSOPEN))
{
/* Not allowed for fpopen. */
_set_errno (EINVAL);
err = -1;
goto out;
}
if (fp)
fflush (fp);
err = func_fp_create (&cookie, fp, modeflags, no_close);
if (err)
goto out;
syshd.type = ES_SYSHD_FD;
syshd.u.fd = fp? fileno (fp): -1;
create_called = 1;
err = create_stream (&stream, cookie, &syshd,
BACKEND_FP, estream_functions_fp,
modeflags, xmode, with_locked_list);
out:
if (err && create_called)
(*estream_functions_fp.public.func_close) (cookie);
return stream;
}
/* Create an estream from the stdio stream FP. This mechanism is
useful in case the stdio streams have special properties and may
not be mixed with fd based functions. This is for example the case
under Windows where the 3 standard streams are associated with the
console whereas a duped and fd-opened stream of one of this stream
won't be associated with the console. As this messes things up it
is easier to keep on using the standard I/O stream as a backend for
estream. */
estream_t
_gpgrt_fpopen (FILE *fp, const char *mode)
{
return do_fpopen (fp, mode, 0, 0);
}
/* Same as es_fpopen but does not close FP at the end. */
estream_t
_gpgrt_fpopen_nc (FILE *fp, const char *mode)
{
return do_fpopen (fp, mode, 1, 0);
}
#ifdef HAVE_W32_SYSTEM
+static estream_t
+do_sockopen (SOCKET sock, const char *mode, int no_close, int with_locked_list)
+{
+ int create_called = 0;
+ estream_t stream = NULL;
+ void *cookie = NULL;
+ unsigned int modeflags, xmode;
+ int err;
+ es_syshd_t syshd;
+
+ err = parse_mode (mode, &modeflags, &xmode, NULL);
+ if (err)
+ goto out;
+ if ((xmode & X_SYSOPEN))
+ {
+ /* Not allowed for sockopen. */
+ _set_errno (EINVAL);
+ err = -1;
+ goto out;
+ }
+
+ err = func_sock_create (&cookie, sock, modeflags, no_close);
+ if (err)
+ goto out;
+
+ syshd.type = ES_SYSHD_SOCK;
+ syshd.u.sock = sock;
+ create_called = 1;
+ err = create_stream (&stream, cookie, &syshd,
+ BACKEND_SOCK, estream_functions_sock,
+ modeflags, xmode, with_locked_list);
+
+ if (!err && stream)
+ {
+ if ((modeflags & O_NONBLOCK))
+ err = stream->intern->func_ioctl (cookie, COOKIE_IOCTL_NONBLOCK,
+ "", NULL);
+ }
+
+ out:
+ if (err && create_called)
+ (*estream_functions_sock.public.func_close) (cookie);
+
+ return stream;
+}
+
+
estream_t
do_w32open (HANDLE hd, const char *mode,
int no_close, int with_locked_list)
{
unsigned int modeflags, cmode, xmode;
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
int err;
es_syshd_t syshd;
/* For obvious reasons we ignore sysmode here. */
err = parse_mode (mode, &modeflags, &xmode, &cmode);
if (err)
goto leave;
/* If we are pollable we create the function cookie with syscall
* clamp disabled. This is because functions are called from
* separate reader and writer threads in w32-stream. */
err = func_w32_create (&cookie, hd, modeflags,
no_close, !!(xmode & X_POLLABLE));
if (err)
goto leave;
syshd.type = ES_SYSHD_HANDLE;
syshd.u.handle = hd;
create_called = 1;
err = create_stream (&stream, cookie, &syshd,
BACKEND_W32, estream_functions_w32,
modeflags, xmode, with_locked_list);
leave:
if (err && create_called)
(*estream_functions_w32.public.func_close) (cookie);
return stream;
}
#endif /*HAVE_W32_SYSTEM*/
static estream_t
do_sysopen (es_syshd_t *syshd, const char *mode, int no_close)
{
estream_t stream;
switch (syshd->type)
{
case ES_SYSHD_FD:
+#ifndef HAVE_W32_SYSTEM
case ES_SYSHD_SOCK:
+#endif
stream = do_fdopen (syshd->u.fd, mode, no_close, 0);
break;
#ifdef HAVE_W32_SYSTEM
+ case ES_SYSHD_SOCK:
+ stream = do_sockopen (syshd->u.sock, mode, no_close, 0);
+ break;
case ES_SYSHD_HANDLE:
stream = do_w32open (syshd->u.handle, mode, no_close, 0);
break;
#endif
/* FIXME: Support RVIDs under Wince? */
default:
_set_errno (EINVAL);
stream = NULL;
}
return stream;
}
/* On POSIX systems this function is an alias for es_fdopen. Under
Windows it uses the bare W32 API and thus a HANDLE instead of a
file descriptor. */
estream_t
_gpgrt_sysopen (es_syshd_t *syshd, const char *mode)
{
return do_sysopen (syshd, mode, 0);
}
/* Same as es_sysopen but the handle/fd will not be closed by
es_fclose. */
estream_t
_gpgrt_sysopen_nc (es_syshd_t *syshd, const char *mode)
{
return do_sysopen (syshd, mode, 1);
}
/* Set custom standard descriptors to be used for stdin, stdout and
stderr. This function needs to be called before any of the
standard streams are accessed. This internal version uses a double
dash inside its name. */
void
_gpgrt__set_std_fd (int no, int fd)
{
/* fprintf (stderr, "es_set_std_fd(%d, %d)\n", no, fd); */
lock_list ();
if (no >= 0 && no < 3 && !custom_std_fds_valid[no])
{
custom_std_fds[no] = fd;
custom_std_fds_valid[no] = 1;
}
unlock_list ();
}
/* Return the stream used for stdin, stdout or stderr.
This internal version uses a double dash inside its name. */
estream_t
_gpgrt__get_std_stream (int fd)
{
estream_list_t list_obj;
estream_t stream = NULL;
fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */
lock_list ();
for (list_obj = estream_list; list_obj; list_obj = list_obj->next)
if (list_obj->stream && list_obj->stream->intern->is_stdstream
&& list_obj->stream->intern->stdstream_fd == fd)
{
stream = list_obj->stream;
break;
}
if (!stream)
{
/* Standard stream not yet created. We first try to create them
from registered file descriptors. */
if (!fd && custom_std_fds_valid[0])
stream = do_fdopen (custom_std_fds[0], "r", 1, 1);
else if (fd == 1 && custom_std_fds_valid[1])
stream = do_fdopen (custom_std_fds[1], "a", 1, 1);
else if (custom_std_fds_valid[2])
stream = do_fdopen (custom_std_fds[2], "a", 1, 1);
if (!stream)
{
/* Second try is to use the standard C streams. */
if (!fd)
stream = do_fpopen (stdin, "r", 1, 1);
else if (fd == 1)
stream = do_fpopen (stdout, "a", 1, 1);
else
stream = do_fpopen (stderr, "a", 1, 1);
}
if (!stream)
{
/* Last try: Create a bit bucket. */
stream = do_fpopen (NULL, fd? "a":"r", 0, 1);
if (!stream)
{
fprintf (stderr, "fatal: error creating a dummy estream"
" for %d: %s\n", fd, strerror (errno));
_gpgrt_abort();
}
}
stream->intern->is_stdstream = 1;
stream->intern->stdstream_fd = fd;
if (fd == 2)
es_set_buffering (stream, NULL, _IOLBF, 0);
fname_set_internal (stream,
fd == 0? "[stdin]" :
fd == 1? "[stdout]" : "[stderr]", 0);
}
unlock_list ();
return stream;
}
/* Note: A "samethread" keyword given in "mode" is ignored and the
* value used by STREAM is used instead. Note that this function is
* the reasons why some of the init and deinit code is split up into
* several functions. */
estream_t
_gpgrt_freopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode,
estream_t _GPGRT__RESTRICT stream)
{
int err;
if (path)
{
unsigned int modeflags, cmode, xmode, dummy;
int create_called;
void *cookie;
int fd;
es_syshd_t syshd;
cookie = NULL;
create_called = 0;
/* Convenience hack so that we can use /dev/null on Windows. */
#ifdef HAVE_W32_SYSTEM
if (!strcmp (path, "/dev/null"))
path = "nul";
#endif
xmode = stream->intern->samethread ? X_SAMETHREAD : 0;
lock_stream (stream);
deinit_stream_obj (stream);
err = parse_mode (mode, &modeflags, &dummy, &cmode);
if (err)
goto leave;
(void)dummy;
err = func_file_create (&cookie, &fd, path, modeflags, cmode);
if (err)
goto leave;
syshd.type = ES_SYSHD_FD;
syshd.u.fd = fd;
create_called = 1;
init_stream_obj (stream, cookie, &syshd, BACKEND_FD,
estream_functions_fd, modeflags, xmode);
leave:
if (err)
{
if (create_called)
func_fd_destroy (cookie);
do_close (stream, 0, 0);
stream = NULL;
}
else
{
if (path)
fname_set_internal (stream, path, 1);
unlock_stream (stream);
}
}
else
{
/* FIXME? We don't support re-opening at the moment. */
_set_errno (EINVAL);
deinit_stream_obj (stream);
do_close (stream, 0, 0);
stream = NULL;
}
return stream;
}
int
_gpgrt_fclose (estream_t stream)
{
int err;
err = do_close (stream, 0, 0);
return err;
}
/* gpgrt_fcancel does the same as gpgrt_fclose but tries to avoid
* flushing out any data still held in internal buffers. It may or
* may not remove a new file created for that stream by the open
* function. */
int
_gpgrt_fcancel (estream_t stream)
{
int err;
err = do_close (stream, 1, 0);
return err;
}
/* This is a special version of es_fclose which can be used with
es_fopenmem to return the memory buffer. This is feature is useful
to write to a memory buffer using estream. Note that the function
does not close the stream if the stream does not support snatching
the buffer. On error NULL is stored at R_BUFFER. Note that if no
write operation has happened, NULL may also be stored at BUFFER on
success. The caller needs to release the returned memory using
gpgrt_free. */
int
_gpgrt_fclose_snatch (estream_t stream, void **r_buffer, size_t *r_buflen)
{
int err;
/* Note: There is no need to lock the stream in a close call. The
object will be destroyed after the close and thus any other
contender for the lock would work on a closed stream. */
if (r_buffer)
{
cookie_ioctl_function_t func_ioctl = stream->intern->func_ioctl;
size_t buflen;
*r_buffer = NULL;
if (!func_ioctl)
{
_set_errno (EOPNOTSUPP);
err = -1;
goto leave;
}
if (stream->flags.writing)
{
err = flush_stream (stream);
if (err)
goto leave;
stream->flags.writing = 0;
}
err = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_SNATCH_BUFFER,
r_buffer, &buflen);
if (err)
goto leave;
if (r_buflen)
*r_buflen = buflen;
}
err = do_close (stream, 0, 0);
leave:
if (err && r_buffer)
{
mem_free (*r_buffer);
*r_buffer = NULL;
}
return err;
}
/* Register or unregister a close notification function for STREAM.
FNC is the function to call and FNC_VALUE the value passed as
second argument. To register the notification the value for MODE
must be 1. If mode is 0 the function tries to remove or disable an
already registered notification; for this to work the value of FNC
and FNC_VALUE must be the same as with the registration and
FNC_VALUE must be a unique value. No error will be returned if
MODE is 0.
FIXME: I think the next comment is not anymore correct:
Unregister should only be used in the error case because it may not
be able to remove memory internally allocated for the onclose
handler.
FIXME: Unregister is not thread safe.
The notification will be called right before the stream is
closed. If gpgrt_fcancel is used, the cancellation of internal
buffers is done before the notifications. The notification handler
may not call any estream function for STREAM, neither direct nor
indirectly. */
int
_gpgrt_onclose (estream_t stream, int mode,
void (*fnc) (estream_t, void*), void *fnc_value)
{
int err;
lock_stream (stream);
err = do_onclose (stream, mode, fnc, fnc_value);
unlock_stream (stream);
return err;
}
int
_gpgrt_fileno_unlocked (estream_t stream)
{
es_syshd_t syshd;
if (_gpgrt_syshd_unlocked (stream, &syshd))
return -1;
switch (syshd.type)
{
case ES_SYSHD_FD: return syshd.u.fd;
case ES_SYSHD_SOCK: return syshd.u.sock;
default:
_set_errno (EINVAL);
return -1;
}
}
/* Return the handle of a stream which has been opened by es_sysopen.
The caller needs to pass a structure which will be filled with the
sys handle. Return 0 on success or true on error and sets errno.
This is the unlocked version. */
int
_gpgrt_syshd_unlocked (estream_t stream, es_syshd_t *syshd)
{
if (!stream || !syshd || stream->intern->syshd.type == ES_SYSHD_NONE)
{
if (syshd)
syshd->type = ES_SYSHD_NONE;
_set_errno (EINVAL);
return -1;
}
*syshd = stream->intern->syshd;
return 0;
}
void
_gpgrt_flockfile (estream_t stream)
{
lock_stream (stream);
}
int
_gpgrt_ftrylockfile (estream_t stream)
{
return trylock_stream (stream);
}
void
_gpgrt_funlockfile (estream_t stream)
{
unlock_stream (stream);
}
int
_gpgrt_fileno (estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt_fileno_unlocked (stream);
unlock_stream (stream);
return ret;
}
/* Return the handle of a stream which has been opened by es_sysopen.
The caller needs to pass a structure which will be filled with the
sys handle. Return 0 on success or true on error and sets errno.
This is the unlocked version. */
int
_gpgrt_syshd (estream_t stream, es_syshd_t *syshd)
{
int ret;
lock_stream (stream);
ret = _gpgrt_syshd_unlocked (stream, syshd);
unlock_stream (stream);
return ret;
}
int
_gpgrt__pending_unlocked (estream_t stream)
{
return check_pending (stream);
}
/* Return true if there is at least one byte pending for read on
STREAM. This does only work if the backend supports checking for
pending bytes and is thus mostly useful with cookie based backends.
Note that if this function is used with cookie based functions, the
read cookie may be called with 0 for the SIZE argument. If bytes
are pending the function is expected to return -1 in this case and
thus deviates from the standard behavior of read(2). */
int
_gpgrt__pending (estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt__pending_unlocked (stream);
unlock_stream (stream);
return ret;
}
int
_gpgrt_feof_unlocked (estream_t stream)
{
return stream->intern->indicators.eof;
}
int
_gpgrt_feof (estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt_feof_unlocked (stream);
unlock_stream (stream);
return ret;
}
int
_gpgrt_ferror_unlocked (estream_t stream)
{
return stream->intern->indicators.err;
}
int
_gpgrt_ferror (estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt_ferror_unlocked (stream);
unlock_stream (stream);
return ret;
}
void
_gpgrt_clearerr_unlocked (estream_t stream)
{
stream->intern->indicators.eof = 0;
stream->intern->indicators.err = 0;
/* We do not reset the HUP indicator because there is no way to
get out of this state. */
}
void
_gpgrt_clearerr (estream_t stream)
{
lock_stream (stream);
_gpgrt_clearerr_unlocked (stream);
unlock_stream (stream);
}
static int
do_fflush (estream_t stream)
{
int err;
if (stream->flags.writing)
err = flush_stream (stream);
else
{
es_empty (stream);
err = 0;
}
return err;
}
int
_gpgrt_fflush (estream_t stream)
{
int err;
if (stream)
{
lock_stream (stream);
err = do_fflush (stream);
unlock_stream (stream);
}
else
{
estream_list_t item;
err = 0;
lock_list ();
for (item = estream_list; item; item = item->next)
if (item->stream)
{
lock_stream (item->stream);
err |= do_fflush (item->stream);
unlock_stream (item->stream);
}
unlock_list ();
}
return err ? EOF : 0;
}
int
_gpgrt_fseek (estream_t stream, long int offset, int whence)
{
int err;
lock_stream (stream);
err = es_seek (stream, offset, whence, NULL);
unlock_stream (stream);
return err;
}
int
_gpgrt_fseeko (estream_t stream, gpgrt_off_t offset, int whence)
{
int err;
lock_stream (stream);
err = es_seek (stream, offset, whence, NULL);
unlock_stream (stream);
return err;
}
long int
_gpgrt_ftell (estream_t stream)
{
long int ret;
lock_stream (stream);
ret = es_offset_calculate (stream);
unlock_stream (stream);
return ret;
}
gpgrt_off_t
_gpgrt_ftello (estream_t stream)
{
gpgrt_off_t ret = -1;
lock_stream (stream);
ret = es_offset_calculate (stream);
unlock_stream (stream);
return ret;
}
void
_gpgrt_rewind (estream_t stream)
{
lock_stream (stream);
es_seek (stream, 0L, SEEK_SET, NULL);
/* Note that es_seek already cleared the EOF flag. */
stream->intern->indicators.err = 0;
unlock_stream (stream);
}
int
_gpgrt_ftruncate (estream_t stream, gpgrt_off_t length)
{
cookie_ioctl_function_t func_ioctl;
int ret;
lock_stream (stream);
func_ioctl = stream->intern->func_ioctl;
if (!func_ioctl)
{
_set_errno (EOPNOTSUPP);
ret = -1;
}
else
{
ret = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_TRUNCATE,
&length, NULL);
}
unlock_stream (stream);
return ret;
}
int
_gpgrt__getc_underflow (estream_t stream)
{
int err;
unsigned char c;
size_t bytes_read;
err = es_readn (stream, &c, 1, &bytes_read);
return (err || (! bytes_read)) ? EOF : c;
}
int
_gpgrt__putc_overflow (int c, estream_t stream)
{
unsigned char d = c;
int err;
err = es_writen (stream, &d, 1, NULL);
return err ? EOF : c;
}
int
_gpgrt_fgetc (estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt_getc_unlocked (stream);
unlock_stream (stream);
return ret;
}
int
_gpgrt_fputc (int c, estream_t stream)
{
int ret;
lock_stream (stream);
ret = _gpgrt_putc_unlocked (c, stream);
unlock_stream (stream);
return ret;
}
int
_gpgrt_ungetc (int c, estream_t stream)
{
unsigned char data = (unsigned char) c;
size_t data_unread;
lock_stream (stream);
es_unreadn (stream, &data, 1, &data_unread);
unlock_stream (stream);
return data_unread ? c : EOF;
}
int
_gpgrt_read (estream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT buffer, size_t bytes_to_read,
size_t *_GPGRT__RESTRICT bytes_read)
{
int err;
if (bytes_to_read)
{
lock_stream (stream);
err = es_readn (stream, buffer, bytes_to_read, bytes_read);
unlock_stream (stream);
}
else
err = 0;
return err;
}
int
_gpgrt_write (estream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write,
size_t *_GPGRT__RESTRICT bytes_written)
{
int err;
if (bytes_to_write)
{
lock_stream (stream);
err = es_writen (stream, buffer, bytes_to_write, bytes_written);
unlock_stream (stream);
}
else
err = 0;
return err;
}
size_t
_gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
estream_t _GPGRT__RESTRICT stream)
{
size_t ret, bytes;
if (size && nitems)
{
lock_stream (stream);
es_readn (stream, ptr, size * nitems, &bytes);
unlock_stream (stream);
ret = bytes / size;
}
else
ret = 0;
return ret;
}
size_t
_gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
estream_t _GPGRT__RESTRICT stream)
{
size_t ret, bytes;
if (size && nitems)
{
lock_stream (stream);
es_writen (stream, ptr, size * nitems, &bytes);
unlock_stream (stream);
ret = bytes / size;
}
else
ret = 0;
return ret;
}
char *
_gpgrt_fgets (char *_GPGRT__RESTRICT buffer, int length,
estream_t _GPGRT__RESTRICT stream)
{
unsigned char *s = (unsigned char*)buffer;
int c;
if (!length)
return NULL;
c = EOF;
lock_stream (stream);
while (length > 1 && (c = _gpgrt_getc_unlocked (stream)) != EOF && c != '\n')
{
*s++ = c;
length--;
}
unlock_stream (stream);
if (c == EOF && s == (unsigned char*)buffer)
return NULL; /* Nothing read. */
if (c != EOF && length > 1)
*s++ = c;
*s = 0;
return buffer;
}
int
_gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s,
estream_t _GPGRT__RESTRICT stream)
{
size_t length;
int err;
length = strlen (s);
err = es_writen (stream, s, length, NULL);
return err ? EOF : 0;
}
int
_gpgrt_fputs (const char *_GPGRT__RESTRICT s, estream_t _GPGRT__RESTRICT stream)
{
size_t length;
int err;
length = strlen (s);
lock_stream (stream);
err = es_writen (stream, s, length, NULL);
unlock_stream (stream);
return err ? EOF : 0;
}
gpgrt_ssize_t
_gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr,
size_t *_GPGRT__RESTRICT n, estream_t _GPGRT__RESTRICT stream)
{
char *line = NULL;
size_t line_n = 0;
int err;
lock_stream (stream);
err = doreadline (stream, 0, &line, &line_n);
unlock_stream (stream);
if (err)
goto out;
if (*n)
{
/* Caller wants us to use his buffer. */
if (*n < (line_n + 1))
{
/* Provided buffer is too small -> resize. */
void *p;
p = mem_realloc (*lineptr, line_n + 1);
if (! p)
err = -1;
else
{
if (*lineptr != p)
*lineptr = p;
}
}
if (! err)
{
memcpy (*lineptr, line, line_n + 1);
if (*n != line_n)
*n = line_n;
}
mem_free (line);
}
else
{
/* Caller wants new buffers. */
*lineptr = line;
*n = line_n;
}
out:
return err ? err : (gpgrt_ssize_t)line_n;
}
/* Same as fgets() but if the provided buffer is too short a larger
one will be allocated. This is similar to getline. A line is
considered a byte stream ending in a LF.
If MAX_LENGTH is not NULL, it shall point to a value with the
maximum allowed allocation.
Returns the length of the line. EOF is indicated by a line of
length zero. A truncated line is indicated my setting the value at
MAX_LENGTH to 0. If the returned value is less then 0 not enough
memory was available or another error occurred; ERRNO is then set
accordingly.
If a line has been truncated, the file pointer is moved forward to
the end of the line so that the next read starts with the next
line. Note that MAX_LENGTH must be re-initialized in this case.
The caller initially needs to provide the address of a variable,
initialized to NULL, at ADDR_OF_BUFFER and don't change this value
anymore with the following invocations. LENGTH_OF_BUFFER should be
the address of a variable, initialized to 0, which is also
maintained by this function. Thus, both paramaters should be
considered the state of this function.
Note: The returned buffer is allocated with enough extra space to
allow the caller to append a CR,LF,Nul. The buffer should be
released using gpgrt_free.
*/
gpgrt_ssize_t
_gpgrt_read_line (estream_t stream,
char **addr_of_buffer, size_t *length_of_buffer,
size_t *max_length)
{
int c;
char *buffer = *addr_of_buffer;
size_t length = *length_of_buffer;
size_t nbytes = 0;
size_t maxlen = max_length? *max_length : 0;
char *p;
if (!buffer)
{
/* No buffer given - allocate a new one. */
length = 256;
buffer = mem_alloc (length);
*addr_of_buffer = buffer;
if (!buffer)
{
*length_of_buffer = 0;
if (max_length)
*max_length = 0;
return -1;
}
*length_of_buffer = length;
}
if (length < 4)
{
/* This should never happen. If it does, the function has been
called with wrong arguments. */
_set_errno (EINVAL);
return -1;
}
length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */
lock_stream (stream);
p = buffer;
while ((c = _gpgrt_getc_unlocked (stream)) != EOF)
{
if (nbytes == length)
{
/* Enlarge the buffer. */
if (maxlen && length > maxlen)
{
/* We are beyond our limit: Skip the rest of the line. */
while (c != '\n' && (c=_gpgrt_getc_unlocked (stream)) != EOF)
;
*p++ = '\n'; /* Always append a LF (we reserved some space). */
nbytes++;
if (max_length)
*max_length = 0; /* Indicate truncation. */
break; /* the while loop. */
}
length += 3; /* Adjust for the reserved bytes. */
length += length < 1024? 256 : 1024;
*addr_of_buffer = mem_realloc (buffer, length);
if (!*addr_of_buffer)
{
int save_errno = errno;
mem_free (buffer);
*length_of_buffer = 0;
if (max_length)
*max_length = 0;
unlock_stream (stream);
_set_errno (save_errno);
return -1;
}
buffer = *addr_of_buffer;
*length_of_buffer = length;
length -= 3;
p = buffer + nbytes;
}
*p++ = c;
nbytes++;
if (c == '\n')
break;
}
*p = 0; /* Make sure the line is a string. */
unlock_stream (stream);
return nbytes;
}
/* Wrapper around free() to match the memory allocation system used by
estream. Should be used for all buffers returned to the caller by
libestream. If a custom allocation handler has been set with
gpgrt_set_alloc_func that register function may be used
instead. This function has been moved to init.c. */
/* void */
/* _gpgrt_free (void *a) */
/* { */
/* mem_free (a); */
/* } */
int
_gpgrt_vfprintf_unlocked (estream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format,
va_list ap)
{
return do_print_stream (stream, sf, sfvalue, format, ap);
}
int
_gpgrt_vfprintf (estream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format,
va_list ap)
{
int ret;
lock_stream (stream);
ret = do_print_stream (stream, sf, sfvalue, format, ap);
unlock_stream (stream);
return ret;
}
int
_gpgrt_fprintf_unlocked (estream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
{
int ret;
va_list ap;
va_start (ap, format);
ret = do_print_stream (stream, NULL, NULL, format, ap);
va_end (ap);
return ret;
}
int
_gpgrt_fprintf (estream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
{
int ret;
va_list ap;
va_start (ap, format);
lock_stream (stream);
ret = do_print_stream (stream, NULL, NULL, format, ap);
unlock_stream (stream);
va_end (ap);
return ret;
}
static int
tmpfd (void)
{
#ifdef HAVE_W32_SYSTEM
int attempts, n;
#ifdef HAVE_W32CE_SYSTEM
wchar_t buffer[MAX_PATH+9+12+1];
# define mystrlen(a) wcslen (a)
wchar_t *name, *p;
#else
char buffer[MAX_PATH+9+12+1];
# define mystrlen(a) strlen (a)
char *name, *p;
#endif
HANDLE file;
int pid = GetCurrentProcessId ();
unsigned int value;
int i;
n = GetTempPath (MAX_PATH+1, buffer);
if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
{
_set_errno (ENOENT);
return -1;
}
p = buffer + mystrlen (buffer);
#ifdef HAVE_W32CE_SYSTEM
wcscpy (p, L"_estream");
#else
strcpy (p, "_estream");
#endif
p += 8;
/* We try to create the directory but don't care about an error as
it may already exist and the CreateFile would throw an error
anyway. */
CreateDirectory (buffer, NULL);
*p++ = '\\';
name = p;
for (attempts=0; attempts < 10; attempts++)
{
p = name;
value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
for (i=0; i < 8; i++)
{
*p++ = tohex (((value >> 28) & 0x0f));
value <<= 4;
}
#ifdef HAVE_W32CE_SYSTEM
wcscpy (p, L".tmp");
#else
strcpy (p, ".tmp");
#endif
file = CreateFile (buffer,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
NULL);
if (file != INVALID_HANDLE_VALUE)
{
#ifdef HAVE_W32CE_SYSTEM
int fd = (int)file;
#else
int fd = _open_osfhandle ((intptr_t)file, 0);
if (fd == -1)
{
CloseHandle (file);
return -1;
}
#endif
return fd;
}
Sleep (1); /* One ms as this is the granularity of GetTickCount. */
}
_set_errno (ENOENT);
return -1;
#else /*!HAVE_W32_SYSTEM*/
FILE *fp;
int fp_fd;
int fd;
fp = NULL;
fd = -1;
fp = tmpfile ();
if (! fp)
goto out;
fp_fd = fileno (fp);
fd = dup (fp_fd);
out:
if (fp)
fclose (fp);
return fd;
#endif /*!HAVE_W32_SYSTEM*/
}
estream_t
_gpgrt_tmpfile (void)
{
unsigned int modeflags;
int create_called = 0;
estream_t stream = NULL;
void *cookie = NULL;
int err;
int fd;
es_syshd_t syshd;
modeflags = O_RDWR | O_TRUNC | O_CREAT;
fd = tmpfd ();
if (fd == -1)
{
err = -1;
goto out;
}
err = func_fd_create (&cookie, fd, modeflags, 0);
if (err)
goto out;
syshd.type = ES_SYSHD_FD;
syshd.u.fd = fd;
create_called = 1;
err = create_stream (&stream, cookie, &syshd,
BACKEND_FD, estream_functions_fd,
modeflags, 0, 0);
out:
if (err)
{
if (create_called)
func_fd_destroy (cookie);
else if (fd != -1)
close (fd);
stream = NULL;
}
return stream;
}
int
_gpgrt_setvbuf (estream_t _GPGRT__RESTRICT stream,
char *_GPGRT__RESTRICT buf, int type, size_t size)
{
int err;
if ((type == _IOFBF || type == _IOLBF || type == _IONBF)
&& (!buf || size || type == _IONBF))
{
lock_stream (stream);
err = es_set_buffering (stream, buf, type, size);
unlock_stream (stream);
}
else
{
_set_errno (EINVAL);
err = -1;
}
return err;
}
/* Put a stream into binary mode. This is only needed for the
standard streams if they are to be used in a binary way. On Unix
systems it is never needed but MSDOS based systems require such a
call. It needs to be called before any I/O is done on STREAM. */
void
_gpgrt_set_binary (estream_t stream)
{
lock_stream (stream);
if (!(stream->intern->modeflags & O_BINARY))
{
stream->intern->modeflags |= O_BINARY;
#ifdef HAVE_DOSISH_SYSTEM
if (stream->intern->func_read == func_fd_read)
{
estream_cookie_fd_t fd_cookie = stream->intern->cookie;
if (!IS_INVALID_FD (fd_cookie->fd))
setmode (fd_cookie->fd, O_BINARY);
}
else if (stream->intern->func_read == func_fp_read)
{
estream_cookie_fp_t fp_cookie = stream->intern->cookie;
if (fp_cookie->fp)
setmode (fileno (fp_cookie->fp), O_BINARY);
}
#endif
}
unlock_stream (stream);
}
/* Set non-blocking mode for STREAM. Use true for ONOFF to enable and
false to disable non-blocking mode. Returns 0 on success or -1 on
error and sets ERRNO. Note that not all backends support
non-blocking mode.
In non-blocking mode a system call will not block but return an
error and set errno to EAGAIN. The estream API always uses EAGAIN
and not EWOULDBLOCK. If a buffered function like es_fgetc() or
es_fgets() returns an error and both, feof() and ferror() return
false the caller may assume that the error condition was EAGAIN.
Switching back from non-blocking to blocking may raise problems
with buffering, thus care should be taken. Although read+write
sockets are supported in theory, switching from write to read may
result into problems because estream may first flush the write
buffers and there is no way to handle that non-blocking (EAGAIN)
case. Explicit flushing should thus be done before before
switching to read. */
int
_gpgrt_set_nonblock (estream_t stream, int onoff)
{
cookie_ioctl_function_t func_ioctl;
int ret;
lock_stream (stream);
func_ioctl = stream->intern->func_ioctl;
if (!func_ioctl)
{
_set_errno (EOPNOTSUPP);
ret = -1;
}
else
{
unsigned int save_flags = stream->intern->modeflags;
if (onoff)
stream->intern->modeflags |= O_NONBLOCK;
else
stream->intern->modeflags &= ~O_NONBLOCK;
ret = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_NONBLOCK,
onoff?"":NULL, NULL);
if (ret)
stream->intern->modeflags = save_flags;
}
unlock_stream (stream);
return ret;
}
/* Return true if STREAM is in non-blocking mode. */
int
_gpgrt_get_nonblock (estream_t stream)
{
int ret;
lock_stream (stream);
ret = !!(stream->intern->modeflags & O_NONBLOCK);
unlock_stream (stream);
return ret;
}
/* A version of poll(2) working on estream handles. Note that not all
estream types work with this function. In contrast to the standard
poll function the gpgrt_poll_t object uses a set of bit flags
instead of the EVENTS and REVENTS members. An item with the IGNORE
flag set is entirely ignored. The TIMEOUT values is given in
milliseconds, a value of -1 waits indefinitely, and a value of 0
returns immediately.
A positive return value gives the number of fds with new
information. A return value of 0 indicates a timeout and -1
indicates an error in which case ERRNO is set. */
int
_gpgrt_poll (gpgrt_poll_t *fds, unsigned int nfds, int timeout)
{
gpgrt_poll_t *item;
int count = 0;
int idx;
#ifndef HAVE_W32_SYSTEM
# ifdef HAVE_POLL_H
struct pollfd *poll_fds = NULL;
nfds_t poll_nfds;
# else
fd_set readfds, writefds, exceptfds;
int any_readfd, any_writefd, any_exceptfd;
int max_fd;
#endif
int fd, ret, any;
#endif /*HAVE_W32_SYSTEM*/
trace (("enter: nfds=%u timeout=%d", nfds, timeout));
if (!fds)
{
_set_errno (EINVAL);
count = -1;
goto leave;
}
/* Clear all response fields (even for ignored items). */
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
item->got_read = 0;
item->got_write = 0;
item->got_oob = 0;
item->got_rdhup = 0;
item->got_err = 0;
item->got_hup = 0;
item->got_nval = 0;
}
/* Check for pending reads. */
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
if (!item->want_read)
continue;
if (_gpgrt__pending (item->stream))
{
item->got_read = 1;
count++;
}
}
/* Check for space in the write buffers. */
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
if (!item->want_write)
continue;
/* FIXME */
}
if (count)
goto leave;
/* Now do the real select. */
#ifdef HAVE_W32_SYSTEM
_gpgrt_pre_syscall ();
count = _gpgrt_w32_poll (fds, nfds, timeout);
_gpgrt_post_syscall ();
#else /*!HAVE_W32_SYSTEM*/
# ifdef HAVE_POLL_H
poll_fds = xtrymalloc (sizeof (*poll_fds)*nfds);
if (!poll_fds)
{
count = -1;
goto leave;
}
poll_nfds = 0;
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
fd = _gpgrt_fileno (item->stream);
if (fd == -1)
continue; /* Stream does not support polling. */
if (item->want_read || item->want_write || item->want_oob)
{
poll_fds[poll_nfds].fd = fd;
poll_fds[poll_nfds].events = ((item->want_read ? POLLIN : 0)
|(item->want_write ? POLLOUT : 0)
|(item->want_oob ? POLLPRI : 0));
poll_fds[poll_nfds].revents = 0;
poll_nfds++;
}
}
_gpgrt_pre_syscall ();
do
ret = poll (poll_fds, poll_nfds, timeout);
while (ret == -1 && (errno == EINTR || errno == EAGAIN));
_gpgrt_post_syscall ();
# else /* !HAVE_POLL_H */
any_readfd = any_writefd = any_exceptfd = 0;
max_fd = 0;
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
fd = _gpgrt_fileno (item->stream);
if (fd == -1)
continue; /* Stream does not support polling. */
if (item->want_read)
{
if (!any_readfd)
{
FD_ZERO (&readfds);
any_readfd = 1;
}
FD_SET (fd, &readfds);
if (fd > max_fd)
max_fd = fd;
}
if (item->want_write)
{
if (!any_writefd)
{
FD_ZERO (&writefds);
any_writefd = 1;
}
FD_SET (fd, &writefds);
if (fd > max_fd)
max_fd = fd;
}
if (item->want_oob)
{
if (!any_exceptfd)
{
FD_ZERO (&exceptfds);
any_exceptfd = 1;
}
FD_SET (fd, &exceptfds);
if (fd > max_fd)
max_fd = fd;
}
}
_gpgrt_pre_syscall ();
do
{
struct timeval timeout_val;
timeout_val.tv_sec = timeout / 1000;
timeout_val.tv_usec = (timeout % 1000) * 1000;
ret = select (max_fd+1,
any_readfd? &readfds : NULL,
any_writefd? &writefds : NULL,
any_exceptfd? &exceptfds : NULL,
timeout == -1 ? NULL : &timeout_val);
}
while (ret == -1 && errno == EINTR);
_gpgrt_post_syscall ();
# endif
if (ret == -1)
{
# ifdef HAVE_POLL_H
trace_errno (1, ("poll failed: "));
# else
trace_errno (1, ("select failed: "));
# endif
count = -1;
goto leave;
}
if (!ret)
{
/* Timeout. Note that in this case we can't return got_err for
* an invalid stream. */
count = 0;
goto leave;
}
# ifdef HAVE_POLL_H
poll_nfds = 0;
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
fd = _gpgrt_fileno (item->stream);
if (fd == -1)
{
item->got_err = 1; /* Stream does not support polling. */
count++;
continue;
}
any = 0;
if (item->stream->intern->indicators.hup)
{
item->got_hup = 1;
any = 1;
}
if (item->want_read && (poll_fds[poll_nfds].revents & (POLLIN|POLLHUP)))
{
item->got_read = 1;
any = 1;
}
if (item->want_write && (poll_fds[poll_nfds].revents & POLLOUT))
{
item->got_write = 1;
any = 1;
}
if (item->want_oob && (poll_fds[poll_nfds].revents & ~(POLLIN|POLLOUT)))
{
item->got_oob = 1;
any = 1;
}
if (item->want_read || item->want_write || item->want_oob)
poll_nfds++;
if (any)
count++;
}
# else
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
if (item->ignore)
continue;
fd = _gpgrt_fileno (item->stream);
if (fd == -1)
{
item->got_err = 1; /* Stream does not support polling. */
count++;
continue;
}
any = 0;
if (item->stream->intern->indicators.hup)
{
item->got_hup = 1;
any = 1;
}
if (item->want_read && FD_ISSET (fd, &readfds))
{
item->got_read = 1;
any = 1;
}
if (item->want_write && FD_ISSET (fd, &writefds))
{
item->got_write = 1;
any = 1;
}
if (item->want_oob && FD_ISSET (fd, &exceptfds))
{
item->got_oob = 1;
any = 1;
}
if (any)
count++;
}
# endif
#endif /*!HAVE_W32_SYSTEM*/
leave:
#ifndef HAVE_W32_SYSTEM
# ifdef HAVE_POLL_H
xfree (poll_fds);
# endif
#endif
#ifdef ENABLE_TRACING
trace (("leave: count=%d", count));
if (count > 0)
{
for (item = fds, idx = 0; idx < nfds; item++, idx++)
{
trace ((" %3d %c%c%c%c%c %c%c%c%c%c%c%c",
idx,
fds[idx].want_read? 'r':'-',
fds[idx].want_write? 'w':'-',
fds[idx].want_oob? 'o':'-',
fds[idx].want_rdhup? 'h':'-',
fds[idx].ignore? 'i':'-',
fds[idx].got_read? 'r':'-',
fds[idx].got_write? 'w':'-',
fds[idx].got_oob? 'o':'-',
fds[idx].got_rdhup? 'h':'-',
fds[idx].got_hup? 'H':'-',
fds[idx].got_err? 'e':'-',
fds[idx].got_nval? 'n':'-'
));
}
}
#endif /*ENABLE_TRACING*/
return count;
}
void
_gpgrt_opaque_set (estream_t stream, void *opaque)
{
lock_stream (stream);
es_opaque_ctrl (stream, opaque, NULL);
unlock_stream (stream);
}
void *
_gpgrt_opaque_get (estream_t stream)
{
void *opaque;
lock_stream (stream);
es_opaque_ctrl (stream, NULL, &opaque);
unlock_stream (stream);
return opaque;
}
static void
fname_set_internal (estream_t stream, const char *fname, int quote)
{
if (stream->intern->printable_fname
&& !stream->intern->printable_fname_inuse)
{
mem_free (stream->intern->printable_fname);
stream->intern->printable_fname = NULL;
}
if (stream->intern->printable_fname)
return; /* Can't change because it is in use. */
if (*fname != '[')
quote = 0;
else
quote = !!quote;
stream->intern->printable_fname = mem_alloc (strlen (fname) + quote + 1);
if (quote)
stream->intern->printable_fname[0] = '\\';
strcpy (stream->intern->printable_fname+quote, fname);
}
/* Set the filename attribute of STREAM. There is no error return.
as long as STREAM is valid. This function is called internally by
functions which open a filename. */
void
_gpgrt_fname_set (estream_t stream, const char *fname)
{
if (fname)
{
lock_stream (stream);
fname_set_internal (stream, fname, 1);
unlock_stream (stream);
}
}
/* Return the filename attribute of STREAM. In case no filename has
been set, "[?]" will be returned. The returned file name is valid
as long as STREAM is valid. */
const char *
_gpgrt_fname_get (estream_t stream)
{
const char *fname;
lock_stream (stream);
fname = stream->intern->printable_fname;
if (fname)
stream->intern->printable_fname_inuse = 1;
unlock_stream (stream);
if (!fname)
fname = "[?]";
return fname;
}
/* Print a BUFFER to STREAM while replacing all control characters and
the characters in DELIMITERS by standard C escape sequences.
Returns 0 on success or -1 on error. If BYTES_WRITTEN is not NULL
the number of bytes actually written are stored at this
address. */
int
_gpgrt_write_sanitized (estream_t _GPGRT__RESTRICT stream,
const void * _GPGRT__RESTRICT buffer, size_t length,
const char * delimiters,
size_t * _GPGRT__RESTRICT bytes_written)
{
const unsigned char *p = buffer;
size_t count = 0;
int ret;
lock_stream (stream);
for (; length; length--, p++, count++)
{
if (*p < 0x20
|| *p == 0x7f
|| (delimiters
&& (strchr (delimiters, *p) || *p == '\\')))
{
_gpgrt_putc_unlocked ('\\', stream);
count++;
if (*p == '\n')
{
_gpgrt_putc_unlocked ('n', stream);
count++;
}
else if (*p == '\r')
{
_gpgrt_putc_unlocked ('r', stream);
count++;
}
else if (*p == '\f')
{
_gpgrt_putc_unlocked ('f', stream);
count++;
}
else if (*p == '\v')
{
_gpgrt_putc_unlocked ('v', stream);
count++;
}
else if (*p == '\b')
{
_gpgrt_putc_unlocked ('b', stream);
count++;
}
else if (!*p)
{
_gpgrt_putc_unlocked('0', stream);
count++;
}
else
{
_gpgrt_fprintf_unlocked (stream, "x%02x", *p);
count += 3;
}
}
else
{
_gpgrt_putc_unlocked (*p, stream);
count++;
}
}
if (bytes_written)
*bytes_written = count;
ret = _gpgrt_ferror_unlocked (stream)? -1 : 0;
unlock_stream (stream);
return ret;
}
/* Write LENGTH bytes of BUFFER to STREAM as a hex encoded string.
RESERVED must be 0. Returns 0 on success or -1 on error. If
BYTES_WRITTEN is not NULL the number of bytes actually written are
stored at this address. */
int
_gpgrt_write_hexstring (estream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t length,
int reserved, size_t *_GPGRT__RESTRICT bytes_written )
{
int ret;
const unsigned char *s;
size_t count = 0;
(void)reserved;
#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
if (!length)
return 0;
lock_stream (stream);
for (s = buffer; length; s++, length--)
{
_gpgrt_putc_unlocked ( tohex ((*s>>4)&15), stream);
_gpgrt_putc_unlocked ( tohex (*s&15), stream);
count += 2;
}
if (bytes_written)
*bytes_written = count;
ret = _gpgrt_ferror_unlocked (stream)? -1 : 0;
unlock_stream (stream);
return ret;
#undef tohex
}
diff --git a/src/gpg-error.h.in b/src/gpg-error.h.in
index b97f38a..ccacf35 100644
--- a/src/gpg-error.h.in
+++ b/src/gpg-error.h.in
@@ -1,1379 +1,1379 @@
/* gpg-error.h or gpgrt.h - Common code for GnuPG and others. -*- c -*-
* Copyright (C) 2001-2020 g10 Code GmbH
*
* This file is part of libgpg-error (aka libgpgrt).
*
* libgpg-error 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.
*
* libgpg-error 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 this program; if not, see .
* SPDX-License-Identifier: LGPL-2.1+
*
* @configure_input@
*/
/* The GnuPG project consists of many components. Error codes are
* exchanged between all components. The common error codes and their
* user-presentable descriptions are kept into a shared library to
* allow adding new error codes and components without recompiling any
* of the other components. In addition to error codes this library
* also features several other groups of functions which are common to
* all GnuPG components. They may be used by independet project as
* well. The interfaces will not change in a backward incompatible way.
*
* An error code together with an error source build up an error
* value. As the error value is been passed from one component to
* another, it preserves the information about the source and nature
* of the error.
*
* A component of the GnuPG project can define the following macros to
* tune the behaviour of the library:
*
* GPG_ERR_SOURCE_DEFAULT: Define to an error source of type
* gpg_err_source_t to make that source the default for gpg_error().
* Otherwise GPG_ERR_SOURCE_UNKNOWN is used as default.
*
* GPG_ERR_ENABLE_GETTEXT_MACROS: Define to provide macros to map the
* internal gettext API to standard names. This has only an effect on
* Windows platforms.
*
* GPGRT_ENABLE_ES_MACROS: Define to provide "es_" macros for the
* estream functions.
*
* GPGRT_ENABLE_LOG_MACROS: Define to provide short versions of the
* log functions.
*
* GPGRT_ENABLE_ARGPARSE_MACROS: Needs to be defined to provide the
* mandatory macros of the argparse interface.
*/
#ifndef GPG_ERROR_H
#define GPG_ERROR_H 1
#ifndef GPGRT_H
#define GPGRT_H 1
#include
#include
#include
/* The version string of this header. */
#define GPG_ERROR_VERSION @version@
#define GPGRT_VERSION @version@
/* The version number of this header. */
#define GPG_ERROR_VERSION_NUMBER @version-number@
#define GPGRT_VERSION_NUMBER @version-number@
#ifdef __GNUC__
# define GPG_ERR_INLINE __inline__
#elif defined(_MSC_VER) && _MSC_VER >= 1300
# define GPG_ERR_INLINE __inline
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
# define GPG_ERR_INLINE inline
#else
# ifndef GPG_ERR_INLINE
# define GPG_ERR_INLINE
# endif
#endif
#ifdef __cplusplus
extern "C" {
#if 0 /* just to make Emacs auto-indent happy */
}
#endif
#endif /* __cplusplus */
/* The error source type gpg_err_source_t.
*
* Where as the Poo out of a welle small
* Taketh his firste springing and his sours.
* --Chaucer.
*/
/* Only use free slots, never change or reorder the existing
* entries. */
typedef enum
{
@include:err-sources@
/* This is one more than the largest allowed entry. */
GPG_ERR_SOURCE_DIM = 128
} gpg_err_source_t;
/* The error code type gpg_err_code_t. */
/* Only use free slots, never change or reorder the existing
* entries. */
typedef enum
{
@include:err-codes@
/* The following error codes are used to map system errors. */
#define GPG_ERR_SYSTEM_ERROR (1 << 15)
@include:errnos@
/* This is one more than the largest allowed entry. */
GPG_ERR_CODE_DIM = 65536
} gpg_err_code_t;
/* The error value type gpg_error_t. */
/* We would really like to use bit-fields in a struct, but using
* structs as return values can cause binary compatibility issues, in
* particular if you want to do it efficiently (also see
* -freg-struct-return option to GCC). */
typedef unsigned int gpg_error_t;
/* We use the lowest 16 bits of gpg_error_t for error codes. The 16th
* bit indicates system errors. */
#define GPG_ERR_CODE_MASK (GPG_ERR_CODE_DIM - 1)
/* Bits 17 to 24 are reserved. */
/* We use the upper 7 bits of gpg_error_t for error sources. */
#define GPG_ERR_SOURCE_MASK (GPG_ERR_SOURCE_DIM - 1)
#define GPG_ERR_SOURCE_SHIFT 24
/* The highest bit is reserved. It shouldn't be used to prevent
* potential negative numbers when transmitting error values as
* text. */
/*
* GCC feature test.
*/
#if __GNUC__
# define _GPG_ERR_GCC_VERSION (__GNUC__ * 10000 \
+ __GNUC_MINOR__ * 100 \
+ __GNUC_PATCHLEVEL__)
#else
# define _GPG_ERR_GCC_VERSION 0
#endif
#undef _GPG_ERR_HAVE_CONSTRUCTOR
#if _GPG_ERR_GCC_VERSION > 30100
# define _GPG_ERR_CONSTRUCTOR __attribute__ ((__constructor__))
# define _GPG_ERR_HAVE_CONSTRUCTOR
#else
# define _GPG_ERR_CONSTRUCTOR
#endif
#define GPGRT_GCC_VERSION _GPG_ERR_GCC_VERSION
#if _GPG_ERR_GCC_VERSION >= 29200
# define _GPGRT__RESTRICT __restrict__
#else
# define _GPGRT__RESTRICT
#endif
/* The noreturn attribute. */
#if _GPG_ERR_GCC_VERSION >= 20500
# define GPGRT_ATTR_NORETURN __attribute__ ((__noreturn__))
#else
# define GPGRT_ATTR_NORETURN
#endif
/* The printf attributes. */
#if _GPG_ERR_GCC_VERSION >= 40400
# define GPGRT_ATTR_PRINTF(f, a) \
__attribute__ ((format(__gnu_printf__,f,a)))
# define GPGRT_ATTR_NR_PRINTF(f, a) \
__attribute__ ((__noreturn__, format(__gnu_printf__,f,a)))
#elif _GPG_ERR_GCC_VERSION >= 20500
# define GPGRT_ATTR_PRINTF(f, a) \
__attribute__ ((format(printf,f,a)))
# define GPGRT_ATTR_NR_PRINTF(f, a) \
__attribute__ ((__noreturn__, format(printf,f,a)))
#else
# define GPGRT_ATTR_PRINTF(f, a)
# define GPGRT_ATTR_NR_PRINTF(f, a)
#endif
#if _GPG_ERR_GCC_VERSION >= 20800
# define GPGRT_ATTR_FORMAT_ARG(a) __attribute__ ((__format_arg__ (a)))
#else
# define GPGRT_ATTR_FORMAT_ARG(a)
#endif
/* The sentinel attribute. */
#if _GPG_ERR_GCC_VERSION >= 40000
# define GPGRT_ATTR_SENTINEL(a) __attribute__ ((sentinel(a)))
#else
# define GPGRT_ATTR_SENTINEL(a)
#endif
/* The used and unused attributes.
* I am not sure since when the unused attribute is really supported.
* In any case it it only needed for gcc versions which print a
* warning. Thus let us require gcc >= 3.5. */
#if _GPG_ERR_GCC_VERSION >= 40000
# define GPGRT_ATTR_USED __attribute__ ((used))
#else
# define GPGRT_ATTR_USED
#endif
#if _GPG_ERR_GCC_VERSION >= 30500
# define GPGRT_ATTR_UNUSED __attribute__ ((unused))
#else
# define GPGRT_ATTR_UNUSED
#endif
/* The deprecated attribute. */
#if _GPG_ERR_GCC_VERSION >= 30100
# define GPGRT_ATTR_DEPRECATED __attribute__ ((__deprecated__))
#else
# define GPGRT_ATTR_DEPRECATED
#endif
/* The pure attribute. */
#if _GPG_ERR_GCC_VERSION >= 29600
# define GPGRT_ATTR_PURE __attribute__ ((__pure__))
#else
# define GPGRT_ATTR_PURE
#endif
/* The malloc attribute. */
#if _GPG_ERR_GCC_VERSION >= 30200
# define GPGRT_ATTR_MALLOC __attribute__ ((__malloc__))
#else
# define GPGRT_ATTR_MALLOC
#endif
/* A macro defined if a GCC style __FUNCTION__ macro is available. */
#undef GPGRT_HAVE_MACRO_FUNCTION
#if _GPG_ERR_GCC_VERSION >= 20500
# define GPGRT_HAVE_MACRO_FUNCTION 1
#endif
/* A macro defined if the pragma GCC push_options is available. */
#undef GPGRT_HAVE_PRAGMA_GCC_PUSH
#if _GPG_ERR_GCC_VERSION >= 40400
# define GPGRT_HAVE_PRAGMA_GCC_PUSH 1
#endif
/* Detect LeakSanitizer (LSan) support for GCC and Clang based on
* whether AddressSanitizer (ASAN) is enabled via -fsanitize=address).
* Note that -fsanitize=leak just affect the linker options which
* cannot be detected here. In that case you have to define the
* GPGRT_HAVE_LEAK_SANITIZER macro manually. */
#ifdef __GNUC__
# ifdef __SANITIZE_ADDRESS__
# define GPGRT_HAVE_LEAK_SANITIZER
# elif defined(__has_feature)
# if __has_feature(address_sanitizer)
# define GPGRT_HAVE_LEAK_SANITIZER
# endif
# endif
#endif
/* The new name for the inline macro. */
#define GPGRT_INLINE GPG_ERR_INLINE
#ifdef GPGRT_HAVE_LEAK_SANITIZER
# include
#endif
/* Mark heap objects as non-leaked memory. */
static GPGRT_INLINE void
gpgrt_annotate_leaked_object (const void *p)
{
#ifdef GPGRT_HAVE_LEAK_SANITIZER
__lsan_ignore_object(p);
#else
(void)p;
#endif
}
/*
* Initialization function.
*/
/* Initialize the library. This function should be run early. */
gpg_error_t gpg_err_init (void) _GPG_ERR_CONSTRUCTOR;
/* If this is defined, the library is already initialized by the
constructor and does not need to be initialized explicitely. */
#undef GPG_ERR_INITIALIZED
#ifdef _GPG_ERR_HAVE_CONSTRUCTOR
# define GPG_ERR_INITIALIZED 1
# define gpgrt_init() do { gpg_err_init (); } while (0)
#else
# define gpgrt_init() do { ; } while (0)
#endif
/* See the source on how to use the deinit function; it is usually not
required. */
void gpg_err_deinit (int mode);
/* Register blocking system I/O clamping functions. */
void gpgrt_set_syscall_clamp (void (*pre)(void), void (*post)(void));
/* Get current I/O clamping functions. */
void gpgrt_get_syscall_clamp (void (**r_pre)(void), void (**r_post)(void));
/* Register a custom malloc/realloc/free function. */
void gpgrt_set_alloc_func (void *(*f)(void *a, size_t n));
/* Register an emergency cleanup handler. */
void gpgrt_add_emergency_cleanup (void (*f)(void));
/* Wrapper around abort to make sure emergency cleanups are run. */
void gpgrt_abort (void) GPGRT_ATTR_NORETURN;
/*
* Constructor and accessor functions.
*/
/* Construct an error value from an error code and source. Within a
* subsystem, use gpg_error. */
static GPG_ERR_INLINE gpg_error_t
gpg_err_make (gpg_err_source_t source, gpg_err_code_t code)
{
return code == GPG_ERR_NO_ERROR ? GPG_ERR_NO_ERROR
: (((source & GPG_ERR_SOURCE_MASK) << GPG_ERR_SOURCE_SHIFT)
| (code & GPG_ERR_CODE_MASK));
}
/* The user should define GPG_ERR_SOURCE_DEFAULT before including this
* file to specify a default source for gpg_error. */
#ifndef GPG_ERR_SOURCE_DEFAULT
#define GPG_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_UNKNOWN
#endif
static GPG_ERR_INLINE gpg_error_t
gpg_error (gpg_err_code_t code)
{
return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, code);
}
/* Retrieve the error code from an error value. */
static GPG_ERR_INLINE gpg_err_code_t
gpg_err_code (gpg_error_t err)
{
return (gpg_err_code_t) (err & GPG_ERR_CODE_MASK);
}
/* Retrieve the error source from an error value. */
static GPG_ERR_INLINE gpg_err_source_t
gpg_err_source (gpg_error_t err)
{
return (gpg_err_source_t) ((err >> GPG_ERR_SOURCE_SHIFT)
& GPG_ERR_SOURCE_MASK);
}
/* String functions. */
/* Return a pointer to a string containing a description of the error
* code in the error value ERR. This function is not thread-safe. */
const char *gpg_strerror (gpg_error_t err);
/* Return the error string for ERR in the user-supplied buffer BUF of
* size BUFLEN. This function is, in contrast to gpg_strerror,
* thread-safe if a thread-safe strerror_r() function is provided by
* the system. If the function succeeds, 0 is returned and BUF
* contains the string describing the error. If the buffer was not
* large enough, ERANGE is returned and BUF contains as much of the
* beginning of the error string as fits into the buffer. */
int gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen);
/* Return a pointer to a string containing a description of the error
* source in the error value ERR. */
const char *gpg_strsource (gpg_error_t err);
/*
* Mapping of system errors (errno).
*/
/* Retrieve the error code for the system error ERR. This returns
* GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
* this). */
gpg_err_code_t gpg_err_code_from_errno (int err);
/* Retrieve the system error for the error code CODE. This returns 0
* if CODE is not a system error code. */
int gpg_err_code_to_errno (gpg_err_code_t code);
/* Retrieve the error code directly from the ERRNO variable. This
* returns GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped
* (report this) and GPG_ERR_MISSING_ERRNO if ERRNO has the value 0. */
gpg_err_code_t gpg_err_code_from_syserror (void);
/* Mapper for SQLite primary error codes. */
static GPG_ERR_INLINE gpg_error_t
gpg_err_code_from_sqlite (int sqlres)
{
return sqlres? GPG_ERR_SQL_OK + (sqlres & 0xff) : 0;
}
/* Set the ERRNO variable. This function is the preferred way to set
* ERRNO due to peculiarities on WindowsCE. */
void gpg_err_set_errno (int err);
/* Return or check the version. Both functions are identical. */
const char *gpgrt_check_version (const char *req_version);
const char *gpg_error_check_version (const char *req_version);
/* System specific type definitions. */
@define:pid_t@
@define:gpgrt_ssize_t@
@define:gpgrt_off_t@
@include:os-add@
/* Self-documenting convenience functions. */
static GPG_ERR_INLINE gpg_error_t
gpg_err_make_from_errno (gpg_err_source_t source, int err)
{
return gpg_err_make (source, gpg_err_code_from_errno (err));
}
static GPG_ERR_INLINE gpg_error_t
gpg_error_from_errno (int err)
{
return gpg_error (gpg_err_code_from_errno (err));
}
static GPG_ERR_INLINE gpg_error_t
gpg_error_from_syserror (void)
{
return gpg_error (gpg_err_code_from_syserror ());
}
/*
* Malloc and friends
*/
void *gpgrt_realloc (void *a, size_t n);
void *gpgrt_reallocarray (void *a, size_t oldnmemb, size_t nmemb, size_t size);
void *gpgrt_malloc (size_t n);
void *gpgrt_calloc (size_t n, size_t m);
char *gpgrt_strdup (const char *string);
char *gpgrt_strconcat (const char *s1, ...) GPGRT_ATTR_SENTINEL(0);
void gpgrt_free (void *a);
/*
* System specific function wrappers.
*/
/* A getenv replacement which mallocs the returned string. */
char *gpgrt_getenv (const char *name);
/* A setenv and a unsetenv replacement.*/
gpg_err_code_t gpgrt_setenv (const char *name,
const char *value, int overwrite);
#define gpgrt_unsetenv(n) gpgrt_setenv ((n), NULL, 1)
/* A wrapper around mkdir using a string for the mode. */
gpg_err_code_t gpgrt_mkdir (const char *name, const char *modestr);
/* A simple wrapper around chdir. */
gpg_err_code_t gpgrt_chdir (const char *name);
/* Return the current WD as a malloced string. */
char *gpgrt_getcwd (void);
/* A wrapper around access to handle UTF-8 on Windows. */
gpg_err_code_t gpgrt_access (const char *fname, int mode);
/*
* Lock functions.
*/
@include:lock-obj@
#define GPGRT_LOCK_DEFINE(name) \
static gpgrt_lock_t name = GPGRT_LOCK_INITIALIZER
/* NB: If GPGRT_LOCK_DEFINE is not used, zero out the lock variable
before passing it to gpgrt_lock_init. */
gpg_err_code_t gpgrt_lock_init (gpgrt_lock_t *lockhd);
gpg_err_code_t gpgrt_lock_lock (gpgrt_lock_t *lockhd);
gpg_err_code_t gpgrt_lock_trylock (gpgrt_lock_t *lockhd);
gpg_err_code_t gpgrt_lock_unlock (gpgrt_lock_t *lockhd);
gpg_err_code_t gpgrt_lock_destroy (gpgrt_lock_t *lockhd);
/*
* Thread functions.
*/
gpg_err_code_t gpgrt_yield (void);
/*
* Estream
*/
/* The definition of this struct is entirely private. You must not
use it for anything. It is only here so some functions can be
implemented as macros. */
struct _gpgrt_stream_internal;
struct _gpgrt__stream
{
/* The layout of this struct must never change. It may be grown,
but only if all functions which access the new members are
versioned. */
/* Various flags. */
struct {
unsigned int magic: 16;
unsigned int writing: 1;
unsigned int reserved: 15;
} flags;
/* A pointer to the stream buffer. */
unsigned char *buffer;
/* The size of the buffer in bytes. */
size_t buffer_size;
/* The length of the usable data in the buffer, only valid when in
read mode (see flags). */
size_t data_len;
/* The current position of the offset pointer, valid in read and
write mode. */
size_t data_offset;
size_t data_flushed;
unsigned char *unread_buffer;
size_t unread_buffer_size;
/* The number of unread bytes. */
size_t unread_data_len;
/* A pointer to our internal data for this stream. */
struct _gpgrt_stream_internal *intern;
};
/* The opaque type for an estream. */
typedef struct _gpgrt__stream *gpgrt_stream_t;
#ifdef GPGRT_ENABLE_ES_MACROS
typedef struct _gpgrt__stream *estream_t;
#endif
typedef @api_ssize_t@ (*gpgrt_cookie_read_function_t) (void *cookie,
void *buffer, size_t size);
typedef @api_ssize_t@ (*gpgrt_cookie_write_function_t) (void *cookie,
const void *buffer,
size_t size);
typedef int (*gpgrt_cookie_seek_function_t) (void *cookie,
gpgrt_off_t *pos, int whence);
typedef int (*gpgrt_cookie_close_function_t) (void *cookie);
struct _gpgrt_cookie_io_functions
{
gpgrt_cookie_read_function_t func_read;
gpgrt_cookie_write_function_t func_write;
gpgrt_cookie_seek_function_t func_seek;
gpgrt_cookie_close_function_t func_close;
};
typedef struct _gpgrt_cookie_io_functions gpgrt_cookie_io_functions_t;
#ifdef GPGRT_ENABLE_ES_MACROS
typedef struct _gpgrt_cookie_io_functions es_cookie_io_functions_t;
#define es_cookie_read_function_t gpgrt_cookie_read_function_t
#define es_cookie_write_function_t gpgrt_cookie_read_function_t
#define es_cookie_seek_function_t gpgrt_cookie_read_function_t
#define es_cookie_close_function_t gpgrt_cookie_read_function_t
#endif
enum gpgrt_syshd_types
{
GPGRT_SYSHD_NONE = 0, /* No system handle available. */
GPGRT_SYSHD_FD = 1, /* A file descriptor as returned by open(). */
GPGRT_SYSHD_SOCK = 2, /* A socket as returned by socket(). */
GPGRT_SYSHD_RVID = 3, /* A rendezvous id (see libassuan's gpgcedev.c). */
GPGRT_SYSHD_HANDLE = 4 /* A HANDLE object (Windows). */
};
struct _gpgrt_syshd
{
enum gpgrt_syshd_types type;
union {
int fd;
- int sock;
+ @SOCKET_t@ sock;
int rvid;
void *handle;
} u;
};
typedef struct _gpgrt_syshd gpgrt_syshd_t;
#ifdef GPGRT_ENABLE_ES_MACROS
typedef struct _gpgrt_syshd es_syshd_t;
#define ES_SYSHD_NONE GPGRT_SYSHD_NONE
#define ES_SYSHD_FD GPGRT_SYSHD_FD
#define ES_SYSHD_SOCK GPGRT_SYSHD_SOCK
#define ES_SYSHD_RVID GPGRT_SYSHD_RVID
#define ES_SYSHD_HANDLE GPGRT_SYSHD_HANDLE
#endif
/* The object used with gpgrt_poll. */
struct _gpgrt_poll_s
{
gpgrt_stream_t stream;
unsigned int want_read:1;
unsigned int want_write:1;
unsigned int want_oob:1;
unsigned int want_rdhup:1;
unsigned int _reserv1:4;
unsigned int got_read:1;
unsigned int got_write:1;
unsigned int got_oob:1;
unsigned int got_rdhup:1;
unsigned int _reserv2:4;
unsigned int got_err:1;
unsigned int got_hup:1;
unsigned int got_nval:1;
unsigned int _reserv3:4;
unsigned int ignore:1;
unsigned int user:8; /* For application use. */
};
typedef struct _gpgrt_poll_s gpgrt_poll_t;
#ifdef GPGRT_ENABLE_ES_MACROS
typedef struct _gpgrt_poll_s es_poll_t;
#endif
/* The type of the string filter function as used by fprintf_sf et al. */
typedef char *(*gpgrt_string_filter_t) (const char *s, int n, void *opaque);
gpgrt_stream_t gpgrt_fopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t gpgrt_mopen (void *_GPGRT__RESTRICT data,
size_t data_n, size_t data_len,
unsigned int grow,
void *(*func_realloc) (void *mem, size_t size),
void (*func_free) (void *mem),
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t gpgrt_fopenmem (size_t memlimit,
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t gpgrt_fopenmem_init (size_t memlimit,
const char *_GPGRT__RESTRICT mode,
const void *data, size_t datalen);
gpgrt_stream_t gpgrt_fdopen (int filedes, const char *mode);
gpgrt_stream_t gpgrt_fdopen_nc (int filedes, const char *mode);
gpgrt_stream_t gpgrt_sysopen (gpgrt_syshd_t *syshd, const char *mode);
gpgrt_stream_t gpgrt_sysopen_nc (gpgrt_syshd_t *syshd, const char *mode);
gpgrt_stream_t gpgrt_fpopen (FILE *fp, const char *mode);
gpgrt_stream_t gpgrt_fpopen_nc (FILE *fp, const char *mode);
gpgrt_stream_t gpgrt_freopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode,
gpgrt_stream_t _GPGRT__RESTRICT stream);
gpgrt_stream_t gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie,
const char *_GPGRT__RESTRICT mode,
gpgrt_cookie_io_functions_t functions);
int gpgrt_fclose (gpgrt_stream_t stream);
int gpgrt_fcancel (gpgrt_stream_t stream);
int gpgrt_fclose_snatch (gpgrt_stream_t stream,
void **r_buffer, size_t *r_buflen);
int gpgrt_onclose (gpgrt_stream_t stream, int mode,
void (*fnc) (gpgrt_stream_t, void*), void *fnc_value);
int gpgrt_fileno (gpgrt_stream_t stream);
int gpgrt_fileno_unlocked (gpgrt_stream_t stream);
int gpgrt_syshd (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
int gpgrt_syshd_unlocked (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
void _gpgrt_set_std_fd (int no, int fd);
gpgrt_stream_t _gpgrt_get_std_stream (int fd);
#define gpgrt_stdin _gpgrt_get_std_stream (0)
#define gpgrt_stdout _gpgrt_get_std_stream (1)
#define gpgrt_stderr _gpgrt_get_std_stream (2)
void gpgrt_flockfile (gpgrt_stream_t stream);
int gpgrt_ftrylockfile (gpgrt_stream_t stream);
void gpgrt_funlockfile (gpgrt_stream_t stream);
int gpgrt_feof (gpgrt_stream_t stream);
int gpgrt_feof_unlocked (gpgrt_stream_t stream);
int gpgrt_ferror (gpgrt_stream_t stream);
int gpgrt_ferror_unlocked (gpgrt_stream_t stream);
void gpgrt_clearerr (gpgrt_stream_t stream);
void gpgrt_clearerr_unlocked (gpgrt_stream_t stream);
int _gpgrt_pending (gpgrt_stream_t stream); /* (private) */
int _gpgrt_pending_unlocked (gpgrt_stream_t stream); /* (private) */
#define gpgrt_pending(stream) _gpgrt_pending (stream)
#define gpgrt_pending_unlocked(stream) \
(((!(stream)->flags.writing) \
&& (((stream)->data_offset < (stream)->data_len) \
|| ((stream)->unread_data_len))) \
? 1 : _gpgrt_pending_unlocked ((stream)))
int gpgrt_fflush (gpgrt_stream_t stream);
int gpgrt_fseek (gpgrt_stream_t stream, long int offset, int whence);
int gpgrt_fseeko (gpgrt_stream_t stream, gpgrt_off_t offset, int whence);
int gpgrt_ftruncate (gpgrt_stream_t stream, gpgrt_off_t length);
long int gpgrt_ftell (gpgrt_stream_t stream);
gpgrt_off_t gpgrt_ftello (gpgrt_stream_t stream);
void gpgrt_rewind (gpgrt_stream_t stream);
int gpgrt_fgetc (gpgrt_stream_t stream);
int gpgrt_fputc (int c, gpgrt_stream_t stream);
int _gpgrt_getc_underflow (gpgrt_stream_t stream); /* (private) */
int _gpgrt_putc_overflow (int c, gpgrt_stream_t stream); /* (private) */
#define gpgrt_getc_unlocked(stream) \
(((!(stream)->flags.writing) \
&& ((stream)->data_offset < (stream)->data_len) \
&& (! (stream)->unread_data_len)) \
? ((int) (stream)->buffer[((stream)->data_offset)++]) \
: _gpgrt_getc_underflow ((stream)))
#define gpgrt_putc_unlocked(c, stream) \
(((stream)->flags.writing \
&& ((stream)->data_offset < (stream)->buffer_size) \
&& (c != '\n')) \
? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \
: _gpgrt_putc_overflow ((c), (stream)))
#define gpgrt_getc(stream) gpgrt_fgetc (stream)
#define gpgrt_putc(c, stream) gpgrt_fputc (c, stream)
int gpgrt_ungetc (int c, gpgrt_stream_t stream);
int gpgrt_read (gpgrt_stream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT buffer, size_t bytes_to_read,
size_t *_GPGRT__RESTRICT bytes_read);
int gpgrt_write (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write,
size_t *_GPGRT__RESTRICT bytes_written);
int gpgrt_write_sanitized (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t length,
const char *delimiters,
size_t *_GPGRT__RESTRICT bytes_written);
int gpgrt_write_hexstring (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t length,
int reserved,
size_t *_GPGRT__RESTRICT bytes_written);
size_t gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
gpgrt_stream_t _GPGRT__RESTRICT stream);
size_t gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size,
size_t nitems, gpgrt_stream_t _GPGRT__RESTRICT stream);
char *gpgrt_fgets (char *_GPGRT__RESTRICT s, int n,
gpgrt_stream_t _GPGRT__RESTRICT stream);
int gpgrt_fputs (const char *_GPGRT__RESTRICT s,
gpgrt_stream_t _GPGRT__RESTRICT stream);
int gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s,
gpgrt_stream_t _GPGRT__RESTRICT stream);
@api_ssize_t@ gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr,
size_t *_GPGRT__RESTRICT n,
gpgrt_stream_t stream);
@api_ssize_t@ gpgrt_read_line (gpgrt_stream_t stream,
char **addr_of_buffer, size_t *length_of_buffer,
size_t *max_length);
int gpgrt_fprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(2,3);
int gpgrt_fprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(2,3);
int gpgrt_fprintf_sf (gpgrt_stream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format,
...) GPGRT_ATTR_PRINTF(4,5);
int gpgrt_fprintf_sf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format,
...) GPGRT_ATTR_PRINTF(4,5);
int gpgrt_printf (const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(1,2);
int gpgrt_printf_unlocked (const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(1,2);
int gpgrt_vfprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, va_list ap)
GPGRT_ATTR_PRINTF(2,0);
int gpgrt_vfprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, va_list ap)
GPGRT_ATTR_PRINTF(2,0);
int gpgrt_setvbuf (gpgrt_stream_t _GPGRT__RESTRICT stream,
char *_GPGRT__RESTRICT buf, int mode, size_t size);
void gpgrt_setbuf (gpgrt_stream_t _GPGRT__RESTRICT stream,
char *_GPGRT__RESTRICT buf);
void gpgrt_set_binary (gpgrt_stream_t stream);
int gpgrt_set_nonblock (gpgrt_stream_t stream, int onoff);
int gpgrt_get_nonblock (gpgrt_stream_t stream);
int gpgrt_poll (gpgrt_poll_t *fdlist, unsigned int nfds, int timeout);
gpgrt_stream_t gpgrt_tmpfile (void);
void gpgrt_opaque_set (gpgrt_stream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT opaque);
void *gpgrt_opaque_get (gpgrt_stream_t stream);
void gpgrt_fname_set (gpgrt_stream_t stream, const char *fname);
const char *gpgrt_fname_get (gpgrt_stream_t stream);
int gpgrt_asprintf (char **r_buf, const char * _GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(2,3);
int gpgrt_vasprintf (char **r_buf, const char * _GPGRT__RESTRICT format,
va_list ap)
GPGRT_ATTR_PRINTF(2,0);
char *gpgrt_bsprintf (const char * _GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(1,2);
char *gpgrt_vbsprintf (const char * _GPGRT__RESTRICT format, va_list ap)
GPGRT_ATTR_PRINTF(1,0);
int gpgrt_snprintf (char *buf, size_t bufsize,
const char * _GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(3,4);
int gpgrt_vsnprintf (char *buf,size_t bufsize,
const char * _GPGRT__RESTRICT format, va_list arg_ptr)
GPGRT_ATTR_PRINTF(3,0);
#ifdef GPGRT_ENABLE_ES_MACROS
# define es_fopen gpgrt_fopen
# define es_mopen gpgrt_mopen
# define es_fopenmem gpgrt_fopenmem
# define es_fopenmem_init gpgrt_fopenmem_init
# define es_fdopen gpgrt_fdopen
# define es_fdopen_nc gpgrt_fdopen_nc
# define es_sysopen gpgrt_sysopen
# define es_sysopen_nc gpgrt_sysopen_nc
# define es_fpopen gpgrt_fpopen
# define es_fpopen_nc gpgrt_fpopen_nc
# define es_freopen gpgrt_freopen
# define es_fopencookie gpgrt_fopencookie
# define es_fclose gpgrt_fclose
# define es_fclose_snatch gpgrt_fclose_snatch
# define es_onclose gpgrt_onclose
# define es_fileno gpgrt_fileno
# define es_fileno_unlocked gpgrt_fileno_unlocked
# define es_syshd gpgrt_syshd
# define es_syshd_unlocked gpgrt_syshd_unlocked
# define es_stdin _gpgrt_get_std_stream (0)
# define es_stdout _gpgrt_get_std_stream (1)
# define es_stderr _gpgrt_get_std_stream (2)
# define es_flockfile gpgrt_flockfile
# define es_ftrylockfile gpgrt_ftrylockfile
# define es_funlockfile gpgrt_funlockfile
# define es_feof gpgrt_feof
# define es_feof_unlocked gpgrt_feof_unlocked
# define es_ferror gpgrt_ferror
# define es_ferror_unlocked gpgrt_ferror_unlocked
# define es_clearerr gpgrt_clearerr
# define es_clearerr_unlocked gpgrt_clearerr_unlocked
# define es_pending gpgrt_pending
# define es_pending_unlocked gpgrt_pending_unlocked
# define es_fflush gpgrt_fflush
# define es_fseek gpgrt_fseek
# define es_fseeko gpgrt_fseeko
# define es_ftruncate gpgrt_ftruncate
# define es_ftell gpgrt_ftell
# define es_ftello gpgrt_ftello
# define es_rewind gpgrt_rewind
# define es_fgetc gpgrt_fgetc
# define es_fputc gpgrt_fputc
# define es_getc_unlocked gpgrt_getc_unlocked
# define es_putc_unlocked gpgrt_putc_unlocked
# define es_getc gpgrt_getc
# define es_putc gpgrt_putc
# define es_ungetc gpgrt_ungetc
# define es_read gpgrt_read
# define es_write gpgrt_write
# define es_write_sanitized gpgrt_write_sanitized
# define es_write_hexstring gpgrt_write_hexstring
# define es_fread gpgrt_fread
# define es_fwrite gpgrt_fwrite
# define es_fgets gpgrt_fgets
# define es_fputs gpgrt_fputs
# define es_fputs_unlocked gpgrt_fputs_unlocked
# define es_getline gpgrt_getline
# define es_read_line gpgrt_read_line
# define es_free gpgrt_free
# define es_fprintf gpgrt_fprintf
# define es_fprintf_unlocked gpgrt_fprintf_unlocked
# define es_printf gpgrt_printf
# define es_printf_unlocked gpgrt_printf_unlocked
# define es_vfprintf gpgrt_vfprintf
# define es_vfprintf_unlocked gpgrt_vfprintf_unlocked
# define es_setvbuf gpgrt_setvbuf
# define es_setbuf gpgrt_setbuf
# define es_set_binary gpgrt_set_binary
# define es_set_nonblock gpgrt_set_nonblock
# define es_get_nonblock gpgrt_get_nonblock
# define es_poll gpgrt_poll
# define es_tmpfile gpgrt_tmpfile
# define es_opaque_set gpgrt_opaque_set
# define es_opaque_get gpgrt_opaque_get
# define es_fname_set gpgrt_fname_set
# define es_fname_get gpgrt_fname_get
# define es_asprintf gpgrt_asprintf
# define es_vasprintf gpgrt_vasprintf
# define es_bsprintf gpgrt_bsprintf
# define es_vbsprintf gpgrt_vbsprintf
#endif /*GPGRT_ENABLE_ES_MACROS*/
/*
* Base64 encode and decode functions.
*/
struct _gpgrt_b64state;
typedef struct _gpgrt_b64state *gpgrt_b64state_t;
gpgrt_b64state_t gpgrt_b64enc_start (gpgrt_stream_t stream, const char *title);
gpg_err_code_t gpgrt_b64enc_write (gpgrt_b64state_t state,
const void *buffer, size_t nbytes);
gpg_err_code_t gpgrt_b64enc_finish (gpgrt_b64state_t state);
gpgrt_b64state_t gpgrt_b64dec_start (const char *title);
gpg_error_t gpgrt_b64dec_proc (gpgrt_b64state_t state,
void *buffer, size_t length,
size_t *r_nbytes);
gpg_error_t gpgrt_b64dec_finish (gpgrt_b64state_t state);
/*
* Logging functions
*/
/* Flag values for gpgrt_log_set_prefix. */
#define GPGRT_LOG_WITH_PREFIX 1
#define GPGRT_LOG_WITH_TIME 2
#define GPGRT_LOG_WITH_PID 4
#define GPGRT_LOG_RUN_DETACHED 256
#define GPGRT_LOG_NO_REGISTRY 512
/* Log levels as used by gpgrt_log. */
enum gpgrt_log_levels
{
GPGRT_LOGLVL_BEGIN,
GPGRT_LOGLVL_CONT,
GPGRT_LOGLVL_INFO,
GPGRT_LOGLVL_WARN,
GPGRT_LOGLVL_ERROR,
GPGRT_LOGLVL_FATAL,
GPGRT_LOGLVL_BUG,
GPGRT_LOGLVL_DEBUG
};
/* The next 4 functions are not thread-safe - call them early. */
void gpgrt_log_set_sink (const char *name, gpgrt_stream_t stream, int fd);
void gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void));
void gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value));
void gpgrt_log_set_prefix (const char *text, unsigned int flags);
int gpgrt_get_errorcount (int clear);
void gpgrt_inc_errorcount (void);
const char *gpgrt_log_get_prefix (unsigned int *flags);
int gpgrt_log_test_fd (int fd);
int gpgrt_log_get_fd (void);
gpgrt_stream_t gpgrt_log_get_stream (void);
void gpgrt_log (int level, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3);
void gpgrt_logv (int level, const char *fmt, va_list arg_ptr);
void gpgrt_logv_prefix (int level, const char *prefix,
const char *fmt, va_list arg_ptr);
void gpgrt_log_string (int level, const char *string);
void gpgrt_log_bug (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
void gpgrt_log_fatal (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
void gpgrt_log_error (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void gpgrt_log_info (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void gpgrt_log_debug (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void gpgrt_log_debug_string (const char *string,
const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3);
void gpgrt_log_printf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void gpgrt_log_printhex (const void *buffer, size_t length,
const char *fmt, ...) GPGRT_ATTR_PRINTF(3,4);
void gpgrt_log_clock (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void gpgrt_log_flush (void);
void _gpgrt_log_assert (const char *expr, const char *file, int line,
const char *func) GPGRT_ATTR_NORETURN;
#ifdef GPGRT_HAVE_MACRO_FUNCTION
# define gpgrt_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__))
#else /*!GPGRT_HAVE_MACRO_FUNCTION*/
# define gpgrt_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL))
#endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
#ifdef GPGRT_ENABLE_LOG_MACROS
# define log_get_errorcount gpgrt_get_errorcount
# define log_inc_errorcount gpgrt_inc_errorcount
# define log_set_file(a) gpgrt_log_set_sink ((a), NULL, -1)
# define log_set_fd(a) gpgrt_log_set_sink (NULL, NULL, (a))
# define log_set_stream(a) gpgrt_log_set_sink (NULL, (a), -1)
# define log_set_socket_dir_cb gpgrt_log_set_socket_dir_cb
# define log_set_pid_suffix_cb gpgrt_log_set_pid_suffix_cb
# define log_set_prefix gpgrt_log_set_prefix
# define log_get_prefix gpgrt_log_get_prefix
# define log_test_fd gpgrt_log_test_fd
# define log_get_fd gpgrt_log_get_fd
# define log_get_stream gpgrt_log_get_stream
# define log_log gpgrt_log
# define log_logv gpgrt_logv
# define log_logv_prefix gpgrt_logv_prefix
# define log_string gpgrt_log_string
# define log_bug gpgrt_log_bug
# define log_fatal gpgrt_log_fatal
# define log_error gpgrt_log_error
# define log_info gpgrt_log_info
# define log_debug gpgrt_log_debug
# define log_debug_string gpgrt_log_debug_string
# define log_printf gpgrt_log_printf
# define log_printhex gpgrt_log_printhex
# define log_clock gpgrt_log_clock
# define log_flush gpgrt_log_flush
# ifdef GPGRT_HAVE_MACRO_FUNCTION
# define log_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__))
# else /*!GPGRT_HAVE_MACRO_FUNCTION*/
# define log_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL))
# endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
#endif /*GPGRT_ENABLE_LOG_MACROS*/
/*
* Spawn functions (Not yet available)
*/
#define GPGRT_SPAWN_NONBLOCK 16 /* Set the streams to non-blocking. */
#define GPGRT_SPAWN_RUN_ASFW 64 /* Use AllowSetForegroundWindow on W32. */
#define GPGRT_SPAWN_DETACHED 128 /* Start the process in the background. */
#if 0
/* Function and convenience macros to create pipes. */
gpg_err_code_t gpgrt_make_pipe (int filedes[2], gpgrt_stream_t *r_fp,
int direction, int nonblock);
#define gpgrt_create_pipe(a) gpgrt_make_pipe ((a),NULL, 0, 0);
#define gpgrt_create_inbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), -1,(c));
#define gpgrt_create_outbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), 1,(c));
/* Fork and exec PGMNAME. */
gpg_err_code_t gpgrt_spawn_process (const char *pgmname, const char *argv[],
int *execpt, void (*preexec)(void),
unsigned int flags,
gpgrt_stream_t *r_infp,
gpgrt_stream_t *r_outfp,
gpgrt_stream_t *r_errfp,
pid_t *pid);
/* Fork and exec PGNNAME and connect the process to the given FDs. */
gpg_err_code_t gpgrt_spawn_process_fd (const char *pgmname, const char *argv[],
int infd, int outfd, int errfd,
pid_t *pid);
/* Fork and exec PGMNAME as a detached process. */
gpg_err_code_t gpgrt_spawn_process_detached (const char *pgmname,
const char *argv[],
const char *envp[] );
/* Wait for a single process. */
gpg_err_code_t gpgrt_wait_process (const char *pgmname, pid_t pid, int hang,
int *r_exitcode);
/* Wait for a multiple processes. */
gpg_err_code_t gpgrt_wait_processes (const char **pgmnames, pid_t *pids,
size_t count, int hang, int *r_exitcodes);
/* Kill the process identified by PID. */
void gpgrt_kill_process (pid_t pid);
/* Release process resources identified by PID. */
void gpgrt_release_process (pid_t pid);
#endif /*0*/
/*
* Option parsing.
*/
struct _gpgrt_argparse_internal_s;
typedef struct
{
int *argc; /* Pointer to ARGC (value subject to change). */
char ***argv; /* Pointer to ARGV (value subject to change). */
unsigned int flags; /* Global flags. May be set prior to calling the
parser. The parser may change the value. */
int err; /* Print error description for last option.
Either 0, ARGPARSE_PRINT_WARNING or
ARGPARSE_PRINT_ERROR. */
unsigned int lineno;/* The current line number. */
int r_opt; /* Returns option code. */
int r_type; /* Returns type of option value. */
union {
int ret_int;
long ret_long;
unsigned long ret_ulong;
char *ret_str;
} r; /* Return values */
struct _gpgrt_argparse_internal_s *internal;
} gpgrt_argparse_t;
typedef struct
{
int short_opt;
const char *long_opt;
unsigned int flags;
const char *description; /* Optional description. */
} gpgrt_opt_t;
#ifdef GPGRT_ENABLE_ARGPARSE_MACROS
/* Global flags for (gpgrt_argparse_t).flags. */
#define ARGPARSE_FLAG_KEEP 1 /* Do not remove options form argv. */
#define ARGPARSE_FLAG_ALL 2 /* Do not stop at last option but return
remaining args with R_OPT set to -1. */
#define ARGPARSE_FLAG_MIXED 4 /* Assume options and args are mixed. */
#define ARGPARSE_FLAG_NOSTOP 8 /* Do not stop processing at "--". */
#define ARGPARSE_FLAG_ARG0 16 /* Do not skip the first arg. */
#define ARGPARSE_FLAG_ONEDASH 32 /* Allow long options with one dash. */
#define ARGPARSE_FLAG_NOVERSION 64 /* No output for "--version". */
#define ARGPARSE_FLAG_RESET 128 /* Request to reset the internal state. */
#define ARGPARSE_FLAG_STOP_SEEN 256 /* Set to true if a "--" has been seen. */
#define ARGPARSE_FLAG_NOLINENO 512 /* Do not zero the lineno field. */
#define ARGPARSE_FLAG_SYS 1024 /* Use system config file. */
#define ARGPARSE_FLAG_USER 2048 /* Use user config file. */
#define ARGPARSE_FLAG_VERBOSE 4096 /* Print additional argparser info. */
#define ARGPARSE_FLAG_USERVERS 8192 /* Try version-ed user config files. */
#define ARGPARSE_FLAG_WITHATTR 16384 /* Return attribute bits. (Make sure */
/* to act upon ARGPARSE_OPT_IGNORE.) */
/* Constants for (gpgrt_argparse_t).err. */
#define ARGPARSE_PRINT_WARNING 1 /* Print a diagnostic. */
#define ARGPARSE_PRINT_ERROR 2 /* Print a diagnostic and call exit. */
/* Special return values of gpgrt_argparse. */
#define ARGPARSE_IS_ARG (-1)
#define ARGPARSE_INVALID_OPTION (-2)
#define ARGPARSE_MISSING_ARG (-3)
#define ARGPARSE_KEYWORD_TOO_LONG (-4)
#define ARGPARSE_READ_ERROR (-5)
#define ARGPARSE_UNEXPECTED_ARG (-6)
#define ARGPARSE_INVALID_COMMAND (-7)
#define ARGPARSE_AMBIGUOUS_OPTION (-8)
#define ARGPARSE_AMBIGUOUS_COMMAND (-9)
#define ARGPARSE_INVALID_ALIAS (-10)
#define ARGPARSE_OUT_OF_CORE (-11)
#define ARGPARSE_INVALID_ARG (-12)
#define ARGPARSE_PERMISSION_ERROR (-13)
#define ARGPARSE_NO_CONFFILE (-14)
#define ARGPARSE_CONFFILE (-15)
#define ARGPARSE_INVALID_META (-16)
#define ARGPARSE_UNKNOWN_META (-17)
#define ARGPARSE_UNEXPECTED_META (-18)
/* Flags for the option descriptor (gpgrt_opt_t)->flags. Note that a
* TYPE constant may be or-ed with the OPT constants but when used as
* return value in r_type these OPT constants are normally not
* included. However with ARGPARSE_FLAG_WITHATTR used and an option
* would normally not be returned, it is returned but
* ARGPARSE_OPT_IGNORE is then set; further ARPARSE_ATTR_* are set.
*/
#define ARGPARSE_TYPE_MASK 0x0007 /* Mask for the type bits. */
#define ARGPARSE_TYPE_NONE 0 /* Does not take an argument. */
#define ARGPARSE_TYPE_INT 1 /* Takes an int argument. */
#define ARGPARSE_TYPE_STRING 2 /* Takes a string argument. */
#define ARGPARSE_TYPE_LONG 3 /* Takes a long argument. */
#define ARGPARSE_TYPE_ULONG 4 /* Takes an unsigned long argument. */
#define ARGPARSE_OPT_OPTIONAL (1<<3) /* Argument is optional. */
#define ARGPARSE_OPT_PREFIX (1<<4) /* Allow 0x etc. prefixed values. */
#define ARGPARSE_OPT_IGNORE (1<<6) /* Ignore command or option. */
#define ARGPARSE_OPT_COMMAND (1<<7) /* The argument is a command. */
#define ARGPARSE_OPT_CONFFILE (1<<8) /* The value is a conffile. */
#define ARGPARSE_OPT_HEADER (1<<9) /* The value is printed as a header. */
#define ARGPARSE_OPT_VERBATIM (1<<10)/* The value is printed verbatim. */
#define ARGPARSE_ATTR_FORCE (1<<14)/* Attribute force is set. */
#define ARGPARSE_ATTR_IGNORE (1<<15)/* Attribute ignore is set. */
/* A set of macros to make option definitions easier to read. */
#define ARGPARSE_x(s,l,t,f,d) \
{ (s), (l), ARGPARSE_TYPE_ ## t | (f), (d) }
#define ARGPARSE_s(s,l,t,d) \
{ (s), (l), ARGPARSE_TYPE_ ## t, (d) }
#define ARGPARSE_s_n(s,l,d) \
{ (s), (l), ARGPARSE_TYPE_NONE, (d) }
#define ARGPARSE_s_i(s,l,d) \
{ (s), (l), ARGPARSE_TYPE_INT, (d) }
#define ARGPARSE_s_s(s,l,d) \
{ (s), (l), ARGPARSE_TYPE_STRING, (d) }
#define ARGPARSE_s_l(s,l,d) \
{ (s), (l), ARGPARSE_TYPE_LONG, (d) }
#define ARGPARSE_s_u(s,l,d) \
{ (s), (l), ARGPARSE_TYPE_ULONG, (d) }
#define ARGPARSE_o(s,l,t,d) \
{ (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_o_n(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_o_i(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_o_s(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_o_l(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_o_u(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_OPTIONAL), (d) }
#define ARGPARSE_p(s,l,t,d) \
{ (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_p_n(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_p_i(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_p_s(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_p_l(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_p_u(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op(s,l,t,d) \
{ (s), (l), (ARGPARSE_TYPE_ ## t \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op_n(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_NONE \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op_i(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_INT \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op_s(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_STRING \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op_l(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_LONG \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_op_u(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_ULONG \
| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
#define ARGPARSE_c(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_COMMAND), (d) }
#define ARGPARSE_conffile(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_STRING|ARGPARSE_OPT_CONFFILE), (d) }
#define ARGPARSE_noconffile(s,l,d) \
{ (s), (l), (ARGPARSE_TYPE_NONE|ARGPARSE_OPT_CONFFILE), (d) }
/* This macro is for stub or obsolete options. */
#define ARGPARSE_ignore(s,l) \
{ (s), (l), (ARGPARSE_OPT_IGNORE), "@" }
/* This is a legacy version of ARGPARSE_verbatim which really does
* verbatim printing. */
#define ARGPARSE_group(s,d) \
{ (s), NULL, 0, (d) }
/* Verbatim print the string D in the help output. It does not make
* use of the "@" hack as ARGPARSE_group does. */
#define ARGPARSE_verbatim(d) \
{ 1, NULL, (ARGPARSE_OPT_VERBATIM), (d) }
/* Same as ARGPARSE_verbatim but also print a colon and a LF. N can
* be used give a symbolic name to the header. Nothing is printed if
* D is the empty string. */
#define ARGPARSE_header(n,d) \
{ 1, (n), (ARGPARSE_OPT_HEADER), (d) }
/* Mark the end of the list (mandatory). */
#define ARGPARSE_end() \
{ 0, NULL, 0, NULL }
#endif /* GPGRT_ENABLE_ARGPARSE_MACROS */
/* Values used for gpgrt_set_confdir. */
#define GPGRT_CONFDIR_USER 1 /* The user's configuration dir. */
#define GPGRT_CONFDIR_SYS 2 /* The systems's configuration dir. */
/* Take care: gpgrt_argparse keeps state in ARG and requires that
* either ARGPARSE_FLAG_RESET is used after OPTS has been changed or
* gpgrt_argparse (NULL, ARG, NULL) is called first. */
int gpgrt_argparse (gpgrt_stream_t fp,
gpgrt_argparse_t *arg, gpgrt_opt_t *opts);
int gpgrt_argparser (gpgrt_argparse_t *arg, gpgrt_opt_t *opts,
const char *confname);
void gpgrt_usage (int level);
const char *gpgrt_strusage (int level);
void gpgrt_set_strusage (const char *(*f)(int));
void gpgrt_set_usage_outfnc (int (*f)(int, const char *));
void gpgrt_set_fixed_string_mapper (const char *(*f)(const char*));
void gpgrt_set_confdir (int what, const char *name);
/*
* Various helper functions
*/
/* Compare arbitrary version strings. For the standard m.n.o version
* numbering scheme a LEVEL of 3 is suitable; see the manual. */
int gpgrt_cmp_version (const char *a, const char *b, int level);
/* Construct a filename from the NULL terminated list of parts. Tilde
* expansion is done for the first argument. The caller must release
* the result using gpgrt_free; on error ERRNO is set and NULL
* returned. The second function returns an absolute filename. */
char *gpgrt_fnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0);
char *gpgrt_absfnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0);
#ifdef __cplusplus
}
#endif
#endif /* GPGRT_H */
#endif /* GPG_ERROR_H */
diff --git a/src/gpgrt-int.h b/src/gpgrt-int.h
index b53ebe9..a541620 100644
--- a/src/gpgrt-int.h
+++ b/src/gpgrt-int.h
@@ -1,847 +1,848 @@
/* gpgrt-int.h - Internal definitions
* Copyright (C) 2014, 2017 g10 Code GmbH
*
* This file is part of libgpg-error.
*
* libgpg-error 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.
*
* libgpg-error 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 this program; if not, see .
* SPDX-License-Identifier: LGPL-2.1+
*/
#ifndef _GPGRT_GPGRT_INT_H
#define _GPGRT_GPGRT_INT_H
#include "gpg-error.h"
#include "visibility.h"
#include "protos.h"
/*
* Internal i18n macros.
*/
#ifdef ENABLE_NLS
# ifdef HAVE_W32_SYSTEM
# include "gettext.h"
# else
# include
# endif
# define _(a) gettext (a)
# ifdef gettext_noop
# define N_(a) gettext_noop (a)
# else
# define N_(a) (a)
# endif
#else /*!ENABLE_NLS*/
# define _(a) (a)
# define N_(a) (a)
#endif /*!ENABLE_NLS */
/*
* Hacks mainly required for Slowaris.
*/
#ifdef _GPGRT_NEED_AFLOCAL
# ifndef HAVE_W32_SYSTEM
# include
# include
# else
# ifdef HAVE_WINSOCK2_H
# include
# endif
# include
# endif
# ifndef PF_LOCAL
# ifdef PF_UNIX
# define PF_LOCAL PF_UNIX
# else
# define PF_LOCAL AF_UNIX
# endif
# endif /*PF_LOCAL*/
# ifndef AF_LOCAL
# define AF_LOCAL AF_UNIX
# endif /*AF_UNIX*/
/* We used to avoid this macro in GnuPG and inlined the AF_LOCAL name
* length computation directly with the little twist of adding 1 extra
* byte. It seems that this was needed once on an old HP/UX box and
* there are also rumours that 4.3 Reno and DEC systems need it. This
* one-off buglet did not harm any current system until it came to Mac
* OS X where the kernel (as of May 2009) exhibited a strange bug: The
* systems basically froze in the connect call if the passed name
* contained an invalid directory part. Ignore the old Unices. */
# ifndef SUN_LEN
# define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) \
+ strlen ((ptr)->sun_path))
# endif /*SUN_LEN*/
#endif /*_GPGRT_NEED_AFLOCAL*/
/*
* Common helper macros.
*/
#ifndef DIM
# define DIM(array) (sizeof (array) / sizeof (*array))
#endif
/*
* Local error function prototypes.
*/
const char *_gpg_strerror (gpg_error_t err);
int _gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen);
const char *_gpg_strsource (gpg_error_t err);
gpg_err_code_t _gpg_err_code_from_errno (int err);
int _gpg_err_code_to_errno (gpg_err_code_t code);
gpg_err_code_t _gpg_err_code_from_syserror (void);
void _gpg_err_set_errno (int err);
gpg_error_t _gpg_err_init (void);
void _gpg_err_deinit (int mode);
void _gpgrt_add_emergency_cleanup (void (*f)(void));
void _gpgrt_abort (void) GPGRT_ATTR_NORETURN;
void _gpgrt_set_alloc_func (void *(*f)(void *a, size_t n));
void *_gpgrt_realloc (void *a, size_t n);
void *_gpgrt_reallocarray (void *a, size_t oldnmemb, size_t nmemb, size_t size);
void *_gpgrt_malloc (size_t n);
void *_gpgrt_calloc (size_t n, size_t m);
char *_gpgrt_strdup (const char *string);
char *_gpgrt_strconcat (const char *s1, ...) GPGRT_ATTR_SENTINEL(0);
void _gpgrt_free (void *a);
/* The next is only to be used by visibility.c. */
char *_gpgrt_strconcat_core (const char *s1, va_list arg_ptr);
#define xfree(a) _gpgrt_free ((a))
#define xtrymalloc(a) _gpgrt_malloc ((a))
#define xtrycalloc(a,b) _gpgrt_calloc ((a),(b))
#define xtryrealloc(a,b) _gpgrt_realloc ((a),(b))
#define xtryreallocarray(a,b,c,d) _gpgrt_reallocarray ((a),(b),(c),(d))
#define xtrystrdup(a) _gpgrt_strdup ((a))
void _gpgrt_pre_syscall (void);
void _gpgrt_post_syscall (void);
const char *_gpg_error_check_version (const char *req_version);
gpg_err_code_t _gpgrt_lock_init (gpgrt_lock_t *lockhd);
gpg_err_code_t _gpgrt_lock_lock (gpgrt_lock_t *lockhd);
gpg_err_code_t _gpgrt_lock_trylock (gpgrt_lock_t *lockhd);
gpg_err_code_t _gpgrt_lock_unlock (gpgrt_lock_t *lockhd);
gpg_err_code_t _gpgrt_lock_destroy (gpgrt_lock_t *lockhd);
gpg_err_code_t _gpgrt_yield (void);
/*
* Tracing
*/
/* The trace macro is used this way:
* trace (("enter - foo=%d bar=%s", foo, bar));
* Note the double parenthesis, they are important.
* To append the current errno to the output, use
* trace_errno (EXTPR,("leave - baz=%d", faz));
* If EXPR evaluates to true the output of strerror (errno)
* is appended to the output. Note that the trace function does
* not modify ERRNO. To enable tracing you need to have this
* #define ENABLE_TRACING "modulename"
* before you include gpgrt-int.h.
*/
#ifdef ENABLE_TRACING
# define trace(X) do { \
_gpgrt_internal_trace_begin \
(ENABLE_TRACING, __func__, __LINE__, 0); \
_gpgrt_internal_trace X; \
_gpgrt_internal_trace_end (); \
} while (0)
# define trace_errno(C,X) do { \
_gpgrt_internal_trace_begin \
(ENABLE_TRACING, __func__, __LINE__, (C)); \
_gpgrt_internal_trace X; \
_gpgrt_internal_trace_end (); \
} while (0)
# define trace_start(X) do { \
_gpgrt_internal_trace_begin \
(ENABLE_TRACING, __func__, __LINE__, 0); \
_gpgrt_internal_trace_printf X; \
} while (0)
# define trace_append(X) do { \
_gpgrt_internal_trace_printf X; \
} while (0)
# define trace_finish(X) do { \
_gpgrt_internal_trace_printf X; \
_gpgrt_internal_trace_end (); \
} while (0)
#else
# define trace(X) do { } while (0)
# define trace_errno(C,X) do { } while (0)
# define trace_start(X) do { } while (0)
# define trace_append(X) do { } while (0)
# define trace_finish(X) do { } while (0)
#endif /*!ENABLE_TRACING*/
void _gpgrt_internal_trace_begin (const char *mod, const char *file, int line,
int with_errno);
void _gpgrt_internal_trace (const char *format,
...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_internal_trace_printf (const char *format,
...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_internal_trace_end (void);
/*
* Local definitions for estream.
*/
#if HAVE_W32_SYSTEM
# ifndef O_NONBLOCK
# define O_NONBLOCK 0x40000000 /* FIXME: Is that safe? */
# endif
#endif
/*
* A private cookie function to implement an internal IOCTL service.
*/
typedef int (*cookie_ioctl_function_t) (void *cookie, int cmd,
void *ptr, size_t *len);
#define COOKIE_IOCTL_SNATCH_BUFFER 1
#define COOKIE_IOCTL_NONBLOCK 2
#define COOKIE_IOCTL_TRUNCATE 3
/* An internal variant of gpgrt_cookie_close_function_t with a slot
* for the ioctl function. */
struct cookie_io_functions_s
{
struct _gpgrt_cookie_io_functions public;
cookie_ioctl_function_t func_ioctl;
};
typedef enum
{
BACKEND_MEM,
BACKEND_FD,
+ BACKEND_SOCK,
BACKEND_W32,
BACKEND_FP,
BACKEND_USER,
BACKEND_W32_POLLABLE
} gpgrt_stream_backend_kind_t;
/*
* A type to hold notification functions.
*/
struct notify_list_s
{
struct notify_list_s *next;
void (*fnc) (estream_t, void*); /* The notification function. */
void *fnc_value; /* The value to be passed to FNC. */
};
typedef struct notify_list_s *notify_list_t;
/*
* Buffer management layer.
*/
/* BUFSIZ on Windows is 512 but on current Linux it is 8k. We better
* use the 8k for Windows as well. */
#ifdef HAVE_W32_SYSTEM
# define BUFFER_BLOCK_SIZE 8192
#else
# define BUFFER_BLOCK_SIZE BUFSIZ
#endif
#define BUFFER_UNREAD_SIZE 16
/*
* The private object describing a stream.
*/
struct _gpgrt_stream_internal
{
unsigned char buffer[BUFFER_BLOCK_SIZE];
unsigned char unread_buffer[BUFFER_UNREAD_SIZE];
gpgrt_lock_t lock; /* Lock. Used by *_stream_lock(). */
gpgrt_stream_backend_kind_t kind;
void *cookie; /* Cookie. */
void *opaque; /* Opaque data. */
unsigned int modeflags; /* Flags for the backend. */
char *printable_fname; /* Malloced filename for es_fname_get. */
gpgrt_off_t offset;
gpgrt_cookie_read_function_t func_read;
gpgrt_cookie_write_function_t func_write;
gpgrt_cookie_seek_function_t func_seek;
gpgrt_cookie_close_function_t func_close;
cookie_ioctl_function_t func_ioctl;
int strategy;
es_syshd_t syshd; /* A copy of the system handle. */
struct
{
unsigned int err: 1;
unsigned int eof: 1;
unsigned int hup: 1;
} indicators;
unsigned int deallocate_buffer: 1;
unsigned int is_stdstream:1; /* This is a standard stream. */
unsigned int stdstream_fd:2; /* 0, 1 or 2 for a standard stream. */
unsigned int printable_fname_inuse: 1; /* es_fname_get has been used. */
unsigned int samethread: 1; /* The "samethread" mode keyword. */
size_t print_ntotal; /* Bytes written from in print_writer. */
notify_list_t onclose; /* On close notify function list. */
};
typedef struct _gpgrt_stream_internal *estream_internal_t;
/*
* Local prototypes for estream.
*/
int _gpgrt_estream_init (void);
void _gpgrt_set_syscall_clamp (void (*pre)(void), void (*post)(void));
void _gpgrt_get_syscall_clamp (void (**r_pre)(void), void (**r_post)(void));
gpgrt_stream_t _gpgrt_fopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t _gpgrt_mopen (void *_GPGRT__RESTRICT data,
size_t data_n, size_t data_len,
unsigned int grow,
void *(*func_realloc) (void *mem, size_t size),
void (*func_free) (void *mem),
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t _gpgrt_fopenmem (size_t memlimit,
const char *_GPGRT__RESTRICT mode);
gpgrt_stream_t _gpgrt_fopenmem_init (size_t memlimit,
const char *_GPGRT__RESTRICT mode,
const void *data, size_t datalen);
gpgrt_stream_t _gpgrt_fdopen (int filedes, const char *mode);
gpgrt_stream_t _gpgrt_fdopen_nc (int filedes, const char *mode);
gpgrt_stream_t _gpgrt_sysopen (gpgrt_syshd_t *syshd, const char *mode);
gpgrt_stream_t _gpgrt_sysopen_nc (gpgrt_syshd_t *syshd, const char *mode);
gpgrt_stream_t _gpgrt_fpopen (FILE *fp, const char *mode);
gpgrt_stream_t _gpgrt_fpopen_nc (FILE *fp, const char *mode);
gpgrt_stream_t _gpgrt_freopen (const char *_GPGRT__RESTRICT path,
const char *_GPGRT__RESTRICT mode,
gpgrt_stream_t _GPGRT__RESTRICT stream);
gpgrt_stream_t _gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie,
const char *_GPGRT__RESTRICT mode,
gpgrt_cookie_io_functions_t functions);
int _gpgrt_fclose (gpgrt_stream_t stream);
int _gpgrt_fcancel (gpgrt_stream_t stream);
int _gpgrt_fclose_snatch (gpgrt_stream_t stream,
void **r_buffer, size_t *r_buflen);
int _gpgrt_onclose (gpgrt_stream_t stream, int mode,
void (*fnc) (gpgrt_stream_t, void*), void *fnc_value);
int _gpgrt_fileno (gpgrt_stream_t stream);
int _gpgrt_fileno_unlocked (gpgrt_stream_t stream);
int _gpgrt_syshd (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
int _gpgrt_syshd_unlocked (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
void _gpgrt__set_std_fd (int no, int fd);
gpgrt_stream_t _gpgrt__get_std_stream (int fd);
/* The es_stderr et al macros are pretty common so that we want to use
* them too. This requires that we redefine them. */
#undef es_stdin
#define es_stdin _gpgrt__get_std_stream (0)
#undef es_stdout
#define es_stdout _gpgrt__get_std_stream (1)
#undef es_stderr
#define es_stderr _gpgrt__get_std_stream (2)
void _gpgrt_flockfile (gpgrt_stream_t stream);
int _gpgrt_ftrylockfile (gpgrt_stream_t stream);
void _gpgrt_funlockfile (gpgrt_stream_t stream);
int _gpgrt_feof (gpgrt_stream_t stream);
int _gpgrt_feof_unlocked (gpgrt_stream_t stream);
int _gpgrt_ferror (gpgrt_stream_t stream);
int _gpgrt_ferror_unlocked (gpgrt_stream_t stream);
void _gpgrt_clearerr (gpgrt_stream_t stream);
void _gpgrt_clearerr_unlocked (gpgrt_stream_t stream);
int _gpgrt__pending (gpgrt_stream_t stream);
int _gpgrt__pending_unlocked (gpgrt_stream_t stream);
int _gpgrt_fflush (gpgrt_stream_t stream);
int _gpgrt_fseek (gpgrt_stream_t stream, long int offset, int whence);
int _gpgrt_fseeko (gpgrt_stream_t stream, gpgrt_off_t offset, int whence);
long int _gpgrt_ftell (gpgrt_stream_t stream);
gpgrt_off_t _gpgrt_ftello (gpgrt_stream_t stream);
void _gpgrt_rewind (gpgrt_stream_t stream);
int _gpgrt_ftruncate (estream_t stream, gpgrt_off_t length);
int _gpgrt_fgetc (gpgrt_stream_t stream);
int _gpgrt_fputc (int c, gpgrt_stream_t stream);
int _gpgrt__getc_underflow (gpgrt_stream_t stream);
int _gpgrt__putc_overflow (int c, gpgrt_stream_t stream);
/* Note: Keeps the next two macros in sync
with their counterparts in gpg-error.h. */
#define _gpgrt_getc_unlocked(stream) \
(((!(stream)->flags.writing) \
&& ((stream)->data_offset < (stream)->data_len) \
&& (! (stream)->unread_data_len)) \
? ((int) (stream)->buffer[((stream)->data_offset)++]) \
: _gpgrt__getc_underflow ((stream)))
#define _gpgrt_putc_unlocked(c, stream) \
(((stream)->flags.writing \
&& ((stream)->data_offset < (stream)->buffer_size) \
&& (c != '\n')) \
? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \
: _gpgrt__putc_overflow ((c), (stream)))
int _gpgrt_ungetc (int c, gpgrt_stream_t stream);
int _gpgrt_read (gpgrt_stream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT buffer, size_t bytes_to_read,
size_t *_GPGRT__RESTRICT bytes_read);
int _gpgrt_write (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write,
size_t *_GPGRT__RESTRICT bytes_written);
int _gpgrt_write_sanitized (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t length,
const char *delimiters,
size_t *_GPGRT__RESTRICT bytes_written);
int _gpgrt_write_hexstring (gpgrt_stream_t _GPGRT__RESTRICT stream,
const void *_GPGRT__RESTRICT buffer, size_t length,
int reserved,
size_t *_GPGRT__RESTRICT bytes_written);
size_t _gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
gpgrt_stream_t _GPGRT__RESTRICT stream);
size_t _gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr,
size_t size, size_t memb,
gpgrt_stream_t _GPGRT__RESTRICT stream);
char *_gpgrt_fgets (char *_GPGRT__RESTRICT s, int n,
gpgrt_stream_t _GPGRT__RESTRICT stream);
int _gpgrt_fputs (const char *_GPGRT__RESTRICT s,
gpgrt_stream_t _GPGRT__RESTRICT stream);
int _gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s,
gpgrt_stream_t _GPGRT__RESTRICT stream);
gpgrt_ssize_t _gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr,
size_t *_GPGRT__RESTRICT n,
gpgrt_stream_t stream);
gpgrt_ssize_t _gpgrt_read_line (gpgrt_stream_t stream,
char **addr_of_buffer, size_t *length_of_buffer,
size_t *max_length);
int _gpgrt_fprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(2,3);
int _gpgrt_fprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
const char *_GPGRT__RESTRICT format, ...)
GPGRT_ATTR_PRINTF(2,3);
int _gpgrt_vfprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format, va_list ap)
GPGRT_ATTR_PRINTF(4,0);
int _gpgrt_vfprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
gpgrt_string_filter_t sf, void *sfvalue,
const char *_GPGRT__RESTRICT format, va_list ap)
GPGRT_ATTR_PRINTF(4,0);
int _gpgrt_setvbuf (gpgrt_stream_t _GPGRT__RESTRICT stream,
char *_GPGRT__RESTRICT buf, int mode, size_t size);
void _gpgrt_set_binary (gpgrt_stream_t stream);
int _gpgrt_set_nonblock (gpgrt_stream_t stream, int onoff);
int _gpgrt_get_nonblock (gpgrt_stream_t stream);
int _gpgrt_poll (gpgrt_poll_t *fds, unsigned int nfds, int timeout);
gpgrt_stream_t _gpgrt_tmpfile (void);
void _gpgrt_opaque_set (gpgrt_stream_t _GPGRT__RESTRICT stream,
void *_GPGRT__RESTRICT opaque);
void *_gpgrt_opaque_get (gpgrt_stream_t stream);
void _gpgrt_fname_set (gpgrt_stream_t stream, const char *fname);
const char *_gpgrt_fname_get (gpgrt_stream_t stream);
#include "estream-printf.h"
/* Make sure we always use our snprintf */
#undef snprintf
#define snprintf _gpgrt_estream_snprintf
#if HAVE_W32_SYSTEM
/* Prototypes for w32-estream.c. */
extern struct cookie_io_functions_s _gpgrt_functions_w32_pollable;
int _gpgrt_w32_pollable_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie,
unsigned int modeflags,
struct cookie_io_functions_s next_functions,
void *next_cookie);
int _gpgrt_w32_poll (gpgrt_poll_t *fds, size_t nfds, int timeout);
#endif /*HAVE_W32_SYSTEM*/
/*
* Local prototypes for the encoders.
*/
struct _gpgrt_b64state
{
int idx;
int quad_count;
estream_t stream;
char *title;
unsigned char radbuf[4];
unsigned int crc;
gpg_err_code_t lasterr;
unsigned int flags;
unsigned int stop_seen:1;
unsigned int invalid_encoding:1;
unsigned int using_decoder:1;
};
gpgrt_b64state_t _gpgrt_b64enc_start (estream_t stream, const char *title);
gpg_err_code_t _gpgrt_b64enc_write (gpgrt_b64state_t state,
const void *buffer, size_t nbytes);
gpg_err_code_t _gpgrt_b64enc_finish (gpgrt_b64state_t state);
gpgrt_b64state_t _gpgrt_b64dec_start (const char *title);
gpg_err_code_t _gpgrt_b64dec_proc (gpgrt_b64state_t state, void *buffer,
size_t length, size_t *r_nbytes);
gpg_err_code_t _gpgrt_b64dec_finish (gpgrt_b64state_t state);
/*
* Local prototypes for logging
*/
int _gpgrt_get_errorcount (int clear);
void _gpgrt_inc_errorcount (void);
void _gpgrt_log_set_sink (const char *name, estream_t stream, int fd);
void _gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void));
void _gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value));
void _gpgrt_log_set_prefix (const char *text, unsigned int flags);
const char *_gpgrt_log_get_prefix (unsigned int *flags);
int _gpgrt_log_test_fd (int fd);
int _gpgrt_log_get_fd (void);
estream_t _gpgrt_log_get_stream (void);
void _gpgrt_log (int level, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3);
void _gpgrt_logv (int level, const char *fmt, va_list arg_ptr);
void _gpgrt_logv_prefix (int level, const char *prefix,
const char *fmt, va_list arg_ptr);
void _gpgrt_log_string (int level, const char *string);
void _gpgrt_log_bug (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
void _gpgrt_log_fatal (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
void _gpgrt_log_error (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_log_info (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_log_debug (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_log_debug_string (const char *string, const char *fmt,
...) GPGRT_ATTR_PRINTF(2,3);
void _gpgrt_log_printf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt_log_flush (void);
void _gpgrt_logv_printhex (const void *buffer, size_t length,
const char *fmt, va_list arg_ptr);
void _gpgrt_log_printhex (const void *buffer, size_t length,
const char *fmt, ...) GPGRT_ATTR_PRINTF(3,4);;
void _gpgrt_logv_clock (const char *fmt, va_list arg_ptr);
void _gpgrt_log_clock (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
void _gpgrt__log_assert (const char *expr, const char *file, int line,
const char *func) GPGRT_ATTR_NORETURN;
/* Redefine the assert macro to use our internal function. */
#undef gpgrt_assert
#ifdef GPGRT_HAVE_MACRO_FUNCTION
#define gpgrt_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt__log_assert (#expr, __FILE__, __LINE__, __FUNCTION__))
#else /*!GPGRT_HAVE_MACRO_FUNCTION*/
/* # define BUG() bug_at( __FILE__ , __LINE__ ) */
#define gpgrt_assert(expr) \
((expr) \
? (void) 0 \
: _gpgrt__log_assert (#expr, __FILE__, __LINE__, NULL))
#endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
/* Note: The next function is only to be used by visibility.c. */
int _gpgrt_logv_internal (int level, int ignore_arg_ptr,
const char *extrastring,
const char *prefmt, const char *fmt,
va_list arg_ptr);
/*
* Local prototypes for the spawn functions.
*
* We put the docs here because we have separate implementations in
* the files spawn-posix.c and spawn-w32.c
*/
/* Return the maximum number of currently allowed file descriptors.
* Only useful on POSIX systems. */
/* int get_max_fds (void); */
/* Close all file descriptors starting with descriptor FIRST. If
* EXCEPT is not NULL, it is expected to be a list of file descriptors
* which are not to close. This list shall be sorted in ascending
* order with its end marked by -1. */
/* void close_all_fds (int first, int *except); */
/* Returns an array with all currently open file descriptors. The end
* of the array is marked by -1. The caller needs to release this
* array using the *standard free* and not with xfree. This allow the
* use of this function right at startup even before libgcrypt has
* been initialized. Returns NULL on error and sets ERRNO accordingly. */
/* int *get_all_open_fds (void); */
/* Create a pipe. The DIRECTION parameter gives the type of the created pipe:
* DIRECTION < 0 := Inbound pipe: On Windows the write end is inheritable.
* DIRECTION > 0 := Outbound pipe: On Windows the read end is inheritable.
* If R_FP is NULL a standard pipe and no stream is created, DIRECTION
* should then be 0. */
gpg_err_code_t _gpgrt_make_pipe (int filedes[2], estream_t *r_fp,
int direction, int nonblock);
/* Convenience macros to create a pipe. */
#define _gpgrt_create_pipe(a) _gpgrt_make_pipe ((a),NULL, 0, 0);
#define _gpgrt_create_inbound_pipe(a,b,c) _gpgrt_make_pipe ((a), (b), -1, (c));
#define _gpgrt_create_outbound_pipe(a,b,c) _gpgrt_make_pipe ((a), (b), 1, (c));
/* Fork and exec the program PGMNAME.
*
* If R_INFP is NULL connect stdin of the new process to /dev/null; if
* it is not NULL store the address of a pointer to a new estream
* there. If R_OUTFP is NULL connect stdout of the new process to
* /dev/null; if it is not NULL store the address of a pointer to a
* new estream there. If R_ERRFP is NULL connect stderr of the new
* process to /dev/null; if it is not NULL store the address of a
* pointer to a new estream there. On success the pid of the new
* process is stored at PID. On error -1 is stored at PID and if
* R_OUTFP or R_ERRFP are not NULL, NULL is stored there.
*
* The arguments for the process are expected in the NULL terminated
* array ARGV. The program name itself should not be included there.
* If PREEXEC is not NULL, the given function will be called right
* before the exec.
*
* IF EXCEPT is not NULL, it is expected to be an ordered list of file
* descriptors, terminated by an entry with the value (-1). These
* file descriptors won't be closed before spawning a new program.
*
* Returns 0 on success or an error code. Calling gpgrt_wait_process
* and gpgrt_release_process is required if the function succeeded.
*
* FLAGS is a bit vector:
*
* GPGRT_SPAWN_NONBLOCK
* If set the two output streams are created in non-blocking
* mode and the input stream is switched to non-blocking mode.
* This is merely a convenience feature because the caller
* could do the same with gpgrt_set_nonblock. Does not yet
* work for Windows.
*
* GPGRT_SPAWN_DETACHED
* If set the process will be started as a background process.
* This flag is only useful under W32 (but not W32CE) systems,
* so that no new console is created and pops up a console
* window when starting the server. Does not work on W32CE.
*
* GPGRT_SPAWN_RUN_ASFW
* On W32 (but not on W32CE) run AllowSetForegroundWindow for
* the child. Note that due to unknown problems this actually
* allows SetForegroundWindow for all children of this process.
*/
gpg_err_code_t
_gpgrt_spawn_process (const char *pgmname, const char *argv[],
int *execpt, void (*preexec)(void), unsigned int flags,
estream_t *r_infp,
estream_t *r_outfp,
estream_t *r_errfp,
pid_t *pid);
/* Simplified version of gpgrt_spawn_process. This function forks and
* then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
* and ERRFD to stderr (any of them may be -1 to connect them to
* /dev/null). The arguments for the process are expected in the NULL
* terminated array ARGV. The program name itself should not be
* included there. Calling gpgrt_wait_process and
* gpgrt_release_process is required. Returns 0 on success or an
* error code. */
gpg_err_code_t _gpgrt_spawn_process_fd (const char *pgmname,
const char *argv[],
int infd, int outfd, int errfd,
pid_t *pid);
/* Spawn a new process and immediately detach from it. The name of
* the program to exec is PGMNAME and its arguments are in ARGV (the
* programname is automatically passed as first argument).
* Environment strings in ENVP are set. An error is returned if
* pgmname is not executable; to make this work it is necessary to
* provide an absolute file name. */
gpg_err_code_t _gpgrt_spawn_process_detached (const char *pgmname,
const char *argv[],
const char *envp[] );
/* If HANG is true, waits for the process identified by PID to exit;
* if HANG is false, checks whether the process has terminated.
* PGMNAME should be the same as supplied to the spawn function and is
* only used for diagnostics. Return values:
*
* 0
* The process exited successful. 0 is stored at R_EXITCODE.
*
* GPG_ERR_GENERAL
* The process exited without success. The exit code of process
* is then stored at R_EXITCODE. An exit code of -1 indicates
* that the process terminated abnormally (e.g. due to a signal).
*
* GPG_ERR_TIMEOUT
* The process is still running (returned only if HANG is false).
*
* GPG_ERR_INV_VALUE
* An invalid PID has been specified.
*
* Other error codes may be returned as well. Unless otherwise noted,
* -1 will be stored at R_EXITCODE. R_EXITCODE may be passed as NULL
* if the exit code is not required (in that case an error message will
* be printed). Note that under Windows PID is not the process id but
* the handle of the process. */
gpg_err_code_t _gpgrt_wait_process (const char *pgmname, pid_t pid, int hang,
int *r_exitcode);
/* Like _gpgrt_wait_process, but for COUNT processes. */
gpg_err_code_t _gpgrt_wait_processes (const char **pgmnames, pid_t *pids,
size_t count, int hang, int *r_exitcodes);
/* Kill a process; that is send an appropriate signal to the process.
* gpgrt_wait_process must be called to actually remove the process
* from the system. An invalid PID is ignored. */
void _gpgrt_kill_process (pid_t pid);
/* Release the process identified by PID. This function is actually
* only required for Windows but it does not harm to always call it.
* It is a nop if PID is invalid. */
void _gpgrt_release_process (pid_t pid);
/*
* Local prototypes for argparse.
*/
int _gpgrt_argparse (estream_t fp, gpgrt_argparse_t *arg, gpgrt_opt_t *opts);
int _gpgrt_argparser (gpgrt_argparse_t *arg, gpgrt_opt_t *opts,
const char *confname);
void _gpgrt_usage (int level);
const char *_gpgrt_strusage (int level);
void _gpgrt_set_strusage (const char *(*f)(int));
void _gpgrt_set_usage_outfnc (int (*fnc)(int, const char *));
void _gpgrt_set_fixed_string_mapper (const char *(*f)(const char*));
void _gpgrt_set_confdir (int what, const char *name);
/*
* Various helper functions
*/
int _gpgrt_cmp_version (const char *a, const char *b, int level);
/*
* Internal platform abstraction functions (sysutils.c)
*/
/* Return true if FD is valid. */
int _gpgrt_fd_valid_p (int fd);
/* A getenv variant which returns a malloced copy. */
char *_gpgrt_getenv (const char *name);
/* A setenv variant which can be used for unsetenv by setting VALUE to
* NULL and OVERRIDE to true. */
gpg_err_code_t _gpgrt_setenv (const char *name,
const char *value, int overwrite);
/* A wrapper around mkdir using a string for the mode (permissions). */
gpg_err_code_t _gpgrt_mkdir (const char *name, const char *modestr);
/* A simple wrapper around chdir. */
gpg_err_code_t _gpgrt_chdir (const char *name);
/* Return the current WD as a malloced string. */
char *_gpgrt_getcwd (void);
/* Wrapper for Windows to allow utf8 file names. */
gpg_err_code_t _gpgrt_access (const char *fname, int mode);
/* Return the home directory of user NAME. */
char *_gpgrt_getpwdir (const char *name);
/* Return the account name of the current user. */
char *_gpgrt_getusername (void);
/* Expand and concat file name parts. */
char *_gpgrt_vfnameconcat (int want_abs, const char *first_part,
va_list arg_ptr);
char *_gpgrt_fnameconcat (const char *first_part,
... ) GPGRT_ATTR_SENTINEL(0);
char *_gpgrt_absfnameconcat (const char *first_part,
... ) GPGRT_ATTR_SENTINEL(0);
/*
* Platform specific functions (Windows)
*/
#ifdef HAVE_W32_SYSTEM
char *_gpgrt_w32_reg_query_string (const char *root,
const char *dir,
const char *name);
char *_gpgrt_w32_reg_get_string (const char *key);
wchar_t *_gpgrt_fname_to_wchar (const char *fname);
#endif /*HAVE_W32_SYSTEM*/
/*
* Missing functions implemented inline.
*/
#ifndef HAVE_STPCPY
static GPG_ERR_INLINE char *
_gpgrt_stpcpy (char *a, const char *b)
{
while (*b)
*a++ = *b++;
*a = 0;
return a;
}
#define stpcpy(a,b) _gpgrt_stpcpy ((a), (b))
#endif /*!HAVE_STPCPY*/
#endif /*_GPGRT_GPGRT_INT_H*/
diff --git a/src/logging.c b/src/logging.c
index e4b7e40..9bc9350 100644
--- a/src/logging.c
+++ b/src/logging.c
@@ -1,1341 +1,1294 @@
/* logging.c - Useful logging functions
* Copyright (C) 1998-2001, 2003-2006, 2009-2010,
* 2017 Free Software Foundation, Inc.
* Copyright (C) 1998-1999, 2001-2006, 2008-2017 Werner Koch
*
* This file is part of Libgpg-error.
*
* Libgpg-error 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.
*
* Libgpg-error 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 this program; if not, see .
* SPDX-License-Identifier: LGPL-2.1+
*
* This file was originally a part of GnuPG.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef HAVE_W32_SYSTEM
# ifdef HAVE_WINSOCK2_H
# include
# endif
# include
#else /*!HAVE_W32_SYSTEM*/
# include
# include
# include
# include
#endif /*!HAVE_W32_SYSTEM*/
#include
#include
/* #include */
#define _GPGRT_NEED_AFLOCAL 1
#include "gpgrt-int.h"
#ifdef HAVE_W32_SYSTEM
# ifndef S_IRWXG
# define S_IRGRP S_IRUSR
# define S_IWGRP S_IWUSR
# endif
# ifndef S_IRWXO
# define S_IROTH S_IRUSR
# define S_IWOTH S_IWUSR
# endif
#endif
-#ifdef HAVE_W32CE_SYSTEM
-# define isatty(a) (0)
-#endif
-
#undef WITH_IPV6
#if defined (AF_INET6) && defined(PF_INET) \
&& defined (INET6_ADDRSTRLEN) && defined(HAVE_INET_PTON)
# define WITH_IPV6 1
#endif
#ifndef EAFNOSUPPORT
# define EAFNOSUPPORT EINVAL
#endif
#ifndef INADDR_NONE /* Slowaris is missing that. */
#define INADDR_NONE ((unsigned long)(-1))
#endif /*INADDR_NONE*/
#ifdef HAVE_W32_SYSTEM
#define sock_close(a) closesocket(a)
#else
#define sock_close(a) close(a)
#endif
static estream_t logstream;
static int log_socket = -1;
static char prefix_buffer[80];
static int with_time;
static int with_prefix;
static int with_pid;
#ifdef HAVE_W32_SYSTEM
static int no_registry;
#endif
static int (*get_pid_suffix_cb)(unsigned long *r_value);
static const char * (*socket_dir_cb)(void);
static int running_detached;
static int force_prefixes;
static int missing_lf;
static int errorcount;
/* An object to convey data to the fmt_string_filter. */
struct fmt_string_filter_s
{
char *last_result;
};
/* Get the error count as maintained by the log fucntions. With CLEAR
* set reset the counter. */
int
_gpgrt_get_errorcount (int clear)
{
int n = errorcount;
if (clear)
errorcount = 0;
return n;
}
/* Increment the error count as maintained by the log functions. */
void
_gpgrt_inc_errorcount (void)
{
/* Protect against counter overflow. */
if (errorcount < 30000)
errorcount++;
}
/* The following 3 functions are used by _gpgrt_fopencookie to write logs
to a socket. */
struct fun_cookie_s
{
int fd;
int quiet;
int want_socket;
int is_socket;
-#ifdef HAVE_W32CE_SYSTEM
- int use_writefile;
-#endif
char name[1];
};
/* Write NBYTES of BUFFER to file descriptor FD. */
static int
writen (int fd, const void *buffer, size_t nbytes, int is_socket)
{
const char *buf = buffer;
size_t nleft = nbytes;
int nwritten;
#ifndef HAVE_W32_SYSTEM
(void)is_socket; /* Not required. */
#endif
while (nleft > 0)
{
#ifdef HAVE_W32_SYSTEM
if (is_socket)
nwritten = send (fd, buf, nleft, 0);
else
#endif
nwritten = write (fd, buf, nleft);
if (nwritten < 0 && errno == EINTR)
continue;
if (nwritten < 0)
return -1;
nleft -= nwritten;
buf = buf + nwritten;
}
return 0;
}
/* Returns true if STR represents a valid port number in decimal
notation and no garbage is following. */
static int
parse_portno (const char *str, unsigned short *r_port)
{
unsigned int value;
for (value=0; *str && (*str >= '0' && *str <= '9'); str++)
{
value = value * 10 + (*str - '0');
if (value > 65535)
return 0;
}
if (*str || !value)
return 0;
*r_port = value;
return 1;
}
static gpgrt_ssize_t
fun_writer (void *cookie_arg, const void *buffer, size_t size)
{
struct fun_cookie_s *cookie = cookie_arg;
- /* FIXME: Use only estream with a callback for socket writing. This
- avoids the ugly mix of fd and estream code. */
-
/* Note that we always try to reconnect to the socket but print
error messages only the first time an error occurred. If
RUNNING_DETACHED is set we don't fall back to stderr and even do
not print any error messages. This is needed because detached
processes often close stderr and by writing to file descriptor 2
we might send the log message to a file not intended for logging
(e.g. a pipe or network connection). */
if (cookie->want_socket && cookie->fd == -1)
{
#ifdef WITH_IPV6
struct sockaddr_in6 srvr_addr_in6;
#endif
struct sockaddr_in srvr_addr_in;
#ifndef HAVE_W32_SYSTEM
struct sockaddr_un srvr_addr_un;
#endif
const char *name_for_err = "";
size_t addrlen;
struct sockaddr *srvr_addr = NULL;
unsigned short port = 0;
int af = AF_LOCAL;
int pf = PF_LOCAL;
const char *name = cookie->name;
/* Not yet open or meanwhile closed due to an error. */
cookie->is_socket = 0;
/* Check whether this is a TCP socket or a local socket. */
if (!strncmp (name, "tcp://", 6) && name[6])
{
name += 6;
af = AF_INET;
pf = PF_INET;
}
#ifndef HAVE_W32_SYSTEM
else if (!strncmp (name, "socket://", 9))
name += 9;
#endif
if (af == AF_LOCAL)
{
addrlen = 0;
#ifndef HAVE_W32_SYSTEM
memset (&srvr_addr, 0, sizeof srvr_addr);
srvr_addr_un.sun_family = af;
if (!*name)
{
if ((name = socket_dir_cb ()) && *name
&& strlen (name) + 7 < sizeof (srvr_addr_un.sun_path)-1)
{
strncpy (srvr_addr_un.sun_path,
name, sizeof (srvr_addr_un.sun_path)-1);
strcat (srvr_addr_un.sun_path, "/S.log");
srvr_addr_un.sun_path[sizeof (srvr_addr_un.sun_path)-1] = 0;
srvr_addr = (struct sockaddr *)&srvr_addr_un;
addrlen = SUN_LEN (&srvr_addr_un);
name_for_err = srvr_addr_un.sun_path;
}
}
else
{
if (strlen (name) < sizeof (srvr_addr_un.sun_path)-1)
{
strncpy (srvr_addr_un.sun_path,
name, sizeof (srvr_addr_un.sun_path)-1);
srvr_addr_un.sun_path[sizeof (srvr_addr_un.sun_path)-1] = 0;
srvr_addr = (struct sockaddr *)&srvr_addr_un;
addrlen = SUN_LEN (&srvr_addr_un);
}
}
#endif /*!HAVE_W32SYSTEM*/
}
else
{
char *addrstr, *p;
#ifdef HAVE_INET_PTON
void *addrbuf = NULL;
#endif /*HAVE_INET_PTON*/
addrstr = _gpgrt_malloc (strlen (name) + 1);
if (!addrstr)
addrlen = 0; /* This indicates an error. */
else if (*name == '[')
{
/* Check for IPv6 literal address. */
strcpy (addrstr, name+1);
p = strchr (addrstr, ']');
if (!p || p[1] != ':' || !parse_portno (p+2, &port))
{
_gpg_err_set_errno (EINVAL);
addrlen = 0;
}
else
{
*p = 0;
#ifdef WITH_IPV6
af = AF_INET6;
pf = PF_INET6;
memset (&srvr_addr_in6, 0, sizeof srvr_addr_in6);
srvr_addr_in6.sin6_family = af;
srvr_addr_in6.sin6_port = htons (port);
#ifdef HAVE_INET_PTON
addrbuf = &srvr_addr_in6.sin6_addr;
#endif /*HAVE_INET_PTON*/
srvr_addr = (struct sockaddr *)&srvr_addr_in6;
addrlen = sizeof srvr_addr_in6;
#else
_gpg_err_set_errno (EAFNOSUPPORT);
addrlen = 0;
#endif
}
}
else
{
/* Check for IPv4 literal address. */
strcpy (addrstr, name);
p = strchr (addrstr, ':');
if (!p || !parse_portno (p+1, &port))
{
_gpg_err_set_errno (EINVAL);
addrlen = 0;
}
else
{
*p = 0;
memset (&srvr_addr_in, 0, sizeof srvr_addr_in);
srvr_addr_in.sin_family = af;
srvr_addr_in.sin_port = htons (port);
#ifdef HAVE_INET_PTON
addrbuf = &srvr_addr_in.sin_addr;
#endif /*HAVE_INET_PTON*/
srvr_addr = (struct sockaddr *)&srvr_addr_in;
addrlen = sizeof srvr_addr_in;
}
}
if (addrlen)
{
#ifdef HAVE_INET_PTON
if (inet_pton (af, addrstr, addrbuf) != 1)
addrlen = 0;
#else /*!HAVE_INET_PTON*/
/* We need to use the old function. If we are here v6
support isn't enabled anyway and thus we can do fine
without. Note that Windows has a compatible inet_pton
function named inetPton, but only since Vista. */
srvr_addr_in.sin_addr.s_addr = inet_addr (addrstr);
if (srvr_addr_in.sin_addr.s_addr == INADDR_NONE)
addrlen = 0;
#endif /*!HAVE_INET_PTON*/
}
_gpgrt_free (addrstr);
}
cookie->fd = addrlen? socket (pf, SOCK_STREAM, 0) : -1;
if (cookie->fd == -1)
{
if (!cookie->quiet && !running_detached
&& isatty (_gpgrt_fileno (es_stderr)))
_gpgrt_fprintf (es_stderr,
"failed to create socket for logging: %s\n",
strerror (errno));
}
else
{
if (connect (cookie->fd, srvr_addr, addrlen) == -1)
{
if (!cookie->quiet && !running_detached
&& isatty (_gpgrt_fileno (es_stderr)))
_gpgrt_fprintf (es_stderr, "can't connect to '%s%s': %s\n",
cookie->name, name_for_err, strerror(errno));
sock_close (cookie->fd);
cookie->fd = -1;
}
}
if (cookie->fd == -1)
{
if (!running_detached)
{
/* Due to all the problems with apps not running
detached but being called with stderr closed or used
for a different purposes, it does not make sense to
switch to stderr. We therefore disable it. */
if (!cookie->quiet)
{
/* fputs ("switching logging to stderr\n", stderr);*/
cookie->quiet = 1;
}
cookie->fd = -1; /*fileno (stderr);*/
}
}
else /* Connection has been established. */
{
cookie->quiet = 0;
cookie->is_socket = 1;
}
}
log_socket = cookie->fd;
if (cookie->fd != -1)
{
-#ifdef HAVE_W32CE_SYSTEM
- if (cookie->use_writefile)
- {
- DWORD nwritten;
-
- WriteFile ((HANDLE)cookie->fd, buffer, size, &nwritten, NULL);
- return (gpgrt_ssize_t)size; /* Okay. */
- }
-#endif
if (!writen (cookie->fd, buffer, size, cookie->is_socket))
return (gpgrt_ssize_t)size; /* Okay. */
}
if (!running_detached && cookie->fd != -1
&& isatty (_gpgrt_fileno (es_stderr)))
{
if (*cookie->name)
_gpgrt_fprintf (es_stderr, "error writing to '%s': %s\n",
cookie->name, strerror(errno));
else
_gpgrt_fprintf (es_stderr, "error writing to file descriptor %d: %s\n",
cookie->fd, strerror(errno));
}
if (cookie->is_socket && cookie->fd != -1)
{
sock_close (cookie->fd);
cookie->fd = -1;
log_socket = -1;
}
return (gpgrt_ssize_t)size;
}
static int
fun_closer (void *cookie_arg)
{
struct fun_cookie_s *cookie = cookie_arg;
if (cookie->fd != -1 && cookie->fd != 2)
sock_close (cookie->fd);
_gpgrt_free (cookie);
log_socket = -1;
return 0;
}
/* Common function to either set the logging to a file or a file
descriptor. */
static void
set_file_fd (const char *name, int fd, estream_t stream)
{
estream_t fp;
int want_socket = 0;
-#ifdef HAVE_W32CE_SYSTEM
- int use_writefile = 0;
-#endif
struct fun_cookie_s *cookie;
/* Close an open log stream. */
if (logstream)
{
if (logstream != es_stderr)
_gpgrt_fclose (logstream);
logstream = NULL;
}
if (stream)
{
/* We don't use a cookie to log directly to a stream. */
fp = stream;
goto leave;
}
/* Figure out what kind of logging we want. */
if (name && !strcmp (name, "-"))
{
- name = NULL;
- fd = _gpgrt_fileno (es_stderr);
+ fp = es_stderr;
+ goto leave;
}
-
- if (name && !strncmp (name, "tcp://", 6) && name[6])
+ else if (name && !strncmp (name, "tcp://", 6) && name[6])
want_socket = 1;
#ifndef HAVE_W32_SYSTEM
else if (name && !strncmp (name, "socket://", 9))
want_socket = 2;
#endif /*HAVE_W32_SYSTEM*/
-#ifdef HAVE_W32CE_SYSTEM
- else if (name && !strcmp (name, "GPG2:"))
- {
- HANDLE hd;
-
- ActivateDevice (L"Drivers\\"GNUPG_NAME"_Log", 0);
- /* Ignore a filename and write the debug output to the GPG2:
- device. */
- hd = CreateFile (L"GPG2:", GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
- fd = (hd == INVALID_HANDLE_VALUE)? -1 : (int)hd;
- name = NULL;
- force_prefixes = 1;
- use_writefile = 1;
- }
-#endif /*HAVE_W32CE_SYSTEM*/
/* Setup a new stream. */
- cookie = _gpgrt_malloc (sizeof *cookie + (name? strlen (name):0));
- if (!cookie)
- return; /* oops */
- strcpy (cookie->name, name? name:"");
- cookie->quiet = 0;
- cookie->is_socket = 0;
- cookie->want_socket = want_socket;
-#ifdef HAVE_W32CE_SYSTEM
- cookie->use_writefile = use_writefile;
-#endif
if (!name)
- cookie->fd = fd;
- else if (want_socket)
- cookie->fd = -1;
+ fp = _gpgrt_fdopen (fd, "w");
+ else if (!want_socket)
+ fp = _gpgrt_fopen (name, "a");
else
{
- do
- cookie->fd = open (name, O_WRONLY|O_APPEND|O_CREAT,
- (S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH));
- while (cookie->fd == -1 && errno == EINTR);
- }
- log_socket = cookie->fd;
+ es_cookie_io_functions_t io = { NULL };
- {
- es_cookie_io_functions_t io = { NULL };
- io.func_write = fun_writer;
- io.func_close = fun_closer;
+ cookie = _gpgrt_malloc (sizeof *cookie + (name? strlen (name):0));
+ if (!cookie)
+ return; /* oops */
+ strcpy (cookie->name, name? name:"");
+ cookie->quiet = 0;
+ cookie->is_socket = 0;
+ cookie->want_socket = want_socket;
+ cookie->fd = -1;
+ log_socket = cookie->fd;
- fp = _gpgrt_fopencookie (cookie, "w", io);
- }
+ io.func_write = fun_writer;
+ io.func_close = fun_closer;
+
+ fp = _gpgrt_fopencookie (cookie, "w", io);
+ }
/* On error default to a stderr based estream. */
if (!fp)
fp = es_stderr;
leave:
_gpgrt_setvbuf (fp, NULL, _IOLBF, 0);
logstream = fp;
/* We always need to print the prefix and the pid for socket mode,
so that the server reading the socket can do something
meaningful. */
force_prefixes = want_socket;
missing_lf = 0;
}
/* Set the file to write log to. The special names NULL and "-" may
* be used to select stderr and names formatted like
* "socket:///home/foo/mylogs" may be used to write the logging to the
* socket "/home/foo/mylogs". If the connection to the socket fails
* or a write error is detected, the function writes to stderr and
* tries the next time again to connect the socket. Calling this
* function with (NULL, NULL, -1) sets the default sink.
* Warning: This function is not thread-safe.
*/
void
_gpgrt_log_set_sink (const char *name, estream_t stream, int fd)
{
if (name && !stream && fd == -1)
set_file_fd (name, -1, NULL);
else if (!name && !stream && fd != -1)
{
if (!_gpgrt_fd_valid_p (fd))
_gpgrt_log_fatal ("gpgrt_log_set_sink: fd is invalid: %s\n",
strerror (errno));
set_file_fd (NULL, fd, NULL);
}
else if (!name && stream && fd == -1)
{
set_file_fd (NULL, -1, stream);
}
else /* default */
set_file_fd ("-", -1, NULL);
}
/* Set a function to retrieve the directory name of a socket if
* only "socket://" has been given to log_set_file.
* Warning: This function is not thread-safe. */
void
_gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void))
{
socket_dir_cb = fnc;
}
/* Warning: This function is not thread-safe. */
void
_gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value))
{
get_pid_suffix_cb = cb;
}
/* Warning: Changing TEXT is not thread-safe. Changing only flags
* might be thread-safe. */
void
_gpgrt_log_set_prefix (const char *text, unsigned int flags)
{
if (text)
{
strncpy (prefix_buffer, text, sizeof (prefix_buffer)-1);
prefix_buffer[sizeof (prefix_buffer)-1] = 0;
}
with_prefix = (flags & GPGRT_LOG_WITH_PREFIX);
with_time = (flags & GPGRT_LOG_WITH_TIME);
with_pid = (flags & GPGRT_LOG_WITH_PID);
running_detached = (flags & GPGRT_LOG_RUN_DETACHED);
#ifdef HAVE_W32_SYSTEM
no_registry = (flags & GPGRT_LOG_NO_REGISTRY);
#endif
}
const char *
_gpgrt_log_get_prefix (unsigned int *flags)
{
if (flags)
{
*flags = 0;
if (with_prefix)
*flags |= GPGRT_LOG_WITH_PREFIX;
if (with_time)
*flags |= GPGRT_LOG_WITH_TIME;
if (with_pid)
*flags |= GPGRT_LOG_WITH_PID;
if (running_detached)
*flags |= GPGRT_LOG_RUN_DETACHED;
#ifdef HAVE_W32_SYSTEM
if (no_registry)
*flags |= GPGRT_LOG_NO_REGISTRY;
#endif
}
return prefix_buffer;
}
/* This function returns true if the file descriptor FD is in use for
* logging. This is preferable over a test using log_get_fd in that
* it allows the logging code to use more then one file descriptor. */
int
_gpgrt_log_test_fd (int fd)
{
if (logstream)
{
int tmp = _gpgrt_fileno (logstream);
if ( tmp != -1 && tmp == fd)
return 1;
}
if (log_socket != -1 && log_socket == fd)
return 1;
return 0;
}
int
_gpgrt_log_get_fd ()
{
return logstream? _gpgrt_fileno (logstream) : -1;
}
estream_t
_gpgrt_log_get_stream ()
{
if (!logstream)
{
/* Make sure a log stream has been set. */
_gpgrt_log_set_sink (NULL, NULL, -1);
if (!logstream)
{
fputs ("gpgrt fatal: failed to init log stream\n", stderr);
_gpgrt_abort ();
}
}
return logstream;
}
/* A filter used with the fprintf_sf function to sanitize the args for
* "%s" format specifiers. */
static char *
fmt_string_filter (const char *string, int no, void *opaque)
{
struct fmt_string_filter_s *state = opaque;
const unsigned char *p;
size_t buflen;
char *d;
int any;
if (no == -1)
{
/* The printf engine asked us to release resources. */
if (state->last_result)
{
_gpgrt_free (state->last_result);
state->last_result = NULL;
}
return NULL;
}
if (!string)
return NULL; /* Nothing to filter - printf handles NULL nicely. */
/* Check whether escaping is needed and count needed length. */
any = 0;
buflen = 1;
for (p = (const unsigned char *)string; *p; p++)
{
switch (*p)
{
case '\n':
case '\r':
case '\f':
case '\v':
case '\b':
case '\t':
case '\a':
case '\\':
buflen += 2;
any = 1;
break;
default:
if (*p < 0x20 || *p == 0x7f)
{
buflen += 5;
any = 1;
}
else
buflen++;
}
}
if (!any)
return (char*)string; /* Nothing to escape. */
/* Create a buffer and escape the input. */
_gpgrt_free (state->last_result);
state->last_result = _gpgrt_malloc (buflen);
if (!state->last_result)
return "[out_of_core_in_format_string_filter]";
d = state->last_result;
for (p = (const unsigned char *)string; *p; p++)
{
switch (*p)
{
case '\n': *d++ = '\\'; *d++ = 'n'; break;
case '\r': *d++ = '\\'; *d++ = 'r'; break;
case '\f': *d++ = '\\'; *d++ = 'f'; break;
case '\v': *d++ = '\\'; *d++ = 'v'; break;
case '\b': *d++ = '\\'; *d++ = 'b'; break;
case '\t': *d++ = '\\'; *d++ = 't'; break;
case '\a': *d++ = '\\'; *d++ = 'a'; break;
case '\\': *d++ = '\\'; *d++ = '\\'; break;
default:
if (*p < 0x20 || *p == 0x7f)
{
snprintf (d, 5, "\\x%02x", *p);
d += 4;
}
else
*d++ = *p;
}
}
*d = 0;
return state->last_result;
}
/* Note: LOGSTREAM is expected to be locked. */
static int
print_prefix (int level, int leading_backspace)
{
int rc;
int length = 0;
if (level != GPGRT_LOGLVL_CONT)
{ /* Note this does not work for multiple line logging as we would
* need to print to a buffer first */
if (with_time && !force_prefixes)
{
struct tm *tp;
time_t atime = time (NULL);
tp = localtime (&atime);
rc = _gpgrt_fprintf_unlocked (logstream,
"%04d-%02d-%02d %02d:%02d:%02d ",
1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
tp->tm_hour, tp->tm_min, tp->tm_sec );
if (rc > 0)
length += rc;
}
if (with_prefix || force_prefixes)
{
_gpgrt_fputs_unlocked (prefix_buffer, logstream);
length += strlen (prefix_buffer);
}
if (with_pid || force_prefixes)
{
unsigned long pidsuf;
int pidfmt;
if (get_pid_suffix_cb && (pidfmt=get_pid_suffix_cb (&pidsuf)))
rc = _gpgrt_fprintf_unlocked (logstream,
pidfmt == 1? "[%u.%lu]":"[%u.%lx]",
(unsigned int)getpid (), pidsuf);
else
rc = _gpgrt_fprintf_unlocked (logstream, "[%u]",
(unsigned int)getpid ());
if (rc > 0)
length += rc;
}
if ((!with_time && (with_prefix || with_pid)) || force_prefixes)
{
_gpgrt_putc_unlocked (':', logstream);
length++;
}
/* A leading backspace suppresses the extra space so that we can
correctly output, programname, filename and linenumber. */
if (!leading_backspace
&& (with_time || with_prefix || with_pid || force_prefixes))
{
_gpgrt_putc_unlocked (' ', logstream);
length++;
}
}
switch (level)
{
case GPGRT_LOGLVL_BEGIN: break;
case GPGRT_LOGLVL_CONT: break;
case GPGRT_LOGLVL_INFO: break;
case GPGRT_LOGLVL_WARN: break;
case GPGRT_LOGLVL_ERROR: break;
case GPGRT_LOGLVL_FATAL:
_gpgrt_fputs_unlocked ("Fatal: ", logstream);
length += 7;
break;
case GPGRT_LOGLVL_BUG:
_gpgrt_fputs_unlocked ("Ohhhh jeeee: ", logstream);
length += 13;
break;
case GPGRT_LOGLVL_DEBUG:
_gpgrt_fputs_unlocked ("DBG: ", logstream);
length += 5;
break;
default:
rc = _gpgrt_fprintf_unlocked (logstream,
"[Unknown log level %d]: ", level);
if (rc > 0)
length += rc;
break;
}
return length;
}
/* Internal worker function. Exported so that we can use it in
* visibility.c. Returs the number of characters printed or 0 if the
* line ends in a LF. */
int
_gpgrt_logv_internal (int level, int ignore_arg_ptr, const char *extrastring,
const char *prefmt, const char *fmt, va_list arg_ptr)
{
int leading_backspace = (fmt && *fmt == '\b');
int length;
int rc;
if (!logstream)
{
#ifdef HAVE_W32_SYSTEM
char *tmp;
tmp = (no_registry
? NULL
: _gpgrt_w32_reg_query_string (NULL, "Software\\\\GNU\\\\GnuPG",
"DefaultLogFile"));
_gpgrt_log_set_sink (tmp && *tmp? tmp : NULL, NULL, -1);
_gpgrt_free (tmp);
#else
/* Make sure a log stream has been set. */
_gpgrt_log_set_sink (NULL, NULL, -1);
#endif
if (!logstream)
{
fputs ("gpgrt fatal: failed to init log stream\n", stderr);
_gpgrt_abort ();
}
}
_gpgrt_flockfile (logstream);
if (missing_lf && level != GPGRT_LOGLVL_CONT)
_gpgrt_putc_unlocked ('\n', logstream );
missing_lf = 0;
length = print_prefix (level, leading_backspace);
if (leading_backspace)
fmt++;
if (fmt)
{
if (prefmt)
{
_gpgrt_fputs_unlocked (prefmt, logstream);
length += strlen (prefmt);
}
if (ignore_arg_ptr)
{ /* This is used by log_string and comes with the extra
* feature that after a LF the next line is indent at the
* length of the prefix. Note that we do not yet include
* the length of the timestamp and pid in the indent
* computation. */
const char *p, *pend;
for (p = fmt; (pend = strchr (p, '\n')); p = pend+1)
{
rc = _gpgrt_fprintf_unlocked (logstream, "%*s%.*s",
(int)((p != fmt
&& (with_prefix || force_prefixes))
?strlen (prefix_buffer)+2:0), "",
(int)(pend - p)+1, p);
if (rc > 0)
length += rc;
}
_gpgrt_fputs_unlocked (p, logstream);
length += strlen (p);
}
else
{
struct fmt_string_filter_s sf = {NULL};
rc = _gpgrt_vfprintf_unlocked (logstream, fmt_string_filter, &sf,
fmt, arg_ptr);
if (rc > 0)
length += rc;
}
if (*fmt && fmt[strlen(fmt)-1] != '\n')
missing_lf = 1;
}
/* If we have an EXTRASTRING print it now while we still hold the
* lock on the logstream. */
if (extrastring)
{
int c;
if (missing_lf)
{
_gpgrt_putc_unlocked ('\n', logstream);
missing_lf = 0;
length = 0;
}
length += print_prefix (level, leading_backspace);
_gpgrt_fputs_unlocked (">> ", logstream);
length += 3;
missing_lf = 1;
while ((c = *extrastring++))
{
missing_lf = 1;
if (c == '\\')
{
_gpgrt_fputs_unlocked ("\\\\", logstream);
length += 2;
}
else if (c == '\r')
{
_gpgrt_fputs_unlocked ("\\r", logstream);
length += 2;
}
else if (c == '\n')
{
_gpgrt_fputs_unlocked ("\\n\n", logstream);
length = 0;
if (*extrastring)
{
length += print_prefix (level, leading_backspace);
_gpgrt_fputs_unlocked (">> ", logstream);
length += 3;
}
else
missing_lf = 0;
}
else
{
_gpgrt_putc_unlocked (c, logstream);
length++;
}
}
if (missing_lf)
{
_gpgrt_putc_unlocked ('\n', logstream);
length = 0;
missing_lf = 0;
}
}
if (level == GPGRT_LOGLVL_FATAL)
{
if (missing_lf)
_gpgrt_putc_unlocked ('\n', logstream);
_gpgrt_funlockfile (logstream);
exit (2);
}
else if (level == GPGRT_LOGLVL_BUG)
{
if (missing_lf)
_gpgrt_putc_unlocked ('\n', logstream );
_gpgrt_funlockfile (logstream);
/* Using backtrace requires a configure test and to pass
* -rdynamic to gcc. Thus we do not enable it now. */
/* { */
/* void *btbuf[20]; */
/* int btidx, btlen; */
/* char **btstr; */
/* btlen = backtrace (btbuf, DIM (btbuf)); */
/* btstr = backtrace_symbols (btbuf, btlen); */
/* if (btstr) */
/* for (btidx=0; btidx < btlen; btidx++) */
/* log_debug ("[%d] %s\n", btidx, btstr[btidx]); */
/* } */
_gpgrt_abort ();
}
else
_gpgrt_funlockfile (logstream);
/* Bumb the error counter for log_error. */
if (level == GPGRT_LOGLVL_ERROR)
_gpgrt_inc_errorcount ();
return length;
}
void
_gpgrt_log (int level, const char *fmt, ...)
{
va_list arg_ptr ;
va_start (arg_ptr, fmt) ;
_gpgrt_logv_internal (level, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
void
_gpgrt_logv (int level, const char *fmt, va_list arg_ptr)
{
_gpgrt_logv_internal (level, 0, NULL, NULL, fmt, arg_ptr);
}
/* Same as log_logv but PREFIX is printed immediately before FMT.
* Note that PREFIX is an additional string and independent of the
* prefix set by gpgrt_log_set_prefix. */
void
_gpgrt_logv_prefix (int level, const char *prefix,
const char *fmt, va_list arg_ptr)
{
_gpgrt_logv_internal (level, 0, NULL, prefix, fmt, arg_ptr);
}
static void
do_log_ignore_arg (int level, const char *str, ...)
{
va_list arg_ptr;
va_start (arg_ptr, str);
_gpgrt_logv_internal (level, 1, NULL, NULL, str, arg_ptr);
va_end (arg_ptr);
}
/* Log STRING at LEVEL but indent from the second line on by the
* length of the prefix. */
void
_gpgrt_log_string (int level, const char *string)
{
/* We need a dummy arg_ptr, but there is no portable way to create
* one. So we call the _gpgrt_logv_internal function through a
* variadic wrapper. */
do_log_ignore_arg (level, string);
}
void
_gpgrt_log_info (const char *fmt, ...)
{
va_list arg_ptr ;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_INFO, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
void
_gpgrt_log_error (const char *fmt, ...)
{
va_list arg_ptr ;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_ERROR, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
void
_gpgrt_log_fatal (const char *fmt, ...)
{
va_list arg_ptr ;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_FATAL, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
_gpgrt_abort (); /* Never called; just to make the compiler happy. */
}
void
_gpgrt_log_bug (const char *fmt, ...)
{
va_list arg_ptr ;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_BUG, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
_gpgrt_abort (); /* Never called; just to make the compiler happy. */
}
void
_gpgrt_log_debug (const char *fmt, ...)
{
va_list arg_ptr;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_DEBUG, 0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
/* The same as log_debug but at the end of the output STRING is
* printed with LFs expanded to include the prefix and a final --end--
* marker. */
void
_gpgrt_log_debug_string (const char *string, const char *fmt, ...)
{
va_list arg_ptr;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (GPGRT_LOGLVL_DEBUG, 0, string, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
void
_gpgrt_log_printf (const char *fmt, ...)
{
va_list arg_ptr;
va_start (arg_ptr, fmt);
_gpgrt_logv_internal (fmt ? GPGRT_LOGLVL_CONT : GPGRT_LOGLVL_BEGIN,
0, NULL, NULL, fmt, arg_ptr);
va_end (arg_ptr);
}
/* Flush the log - this is useful to make sure that the trailing
linefeed has been printed. */
void
_gpgrt_log_flush (void)
{
do_log_ignore_arg (GPGRT_LOGLVL_CONT, NULL);
}
/* Print a hexdump of (BUFFER,LENGTH). With FMT passed as NULL print
* just the raw dump (in this case ARG_PTR is not used), with FMT
* being an empty string, print a trailing linefeed, otherwise print
* an entire debug line with the expanded FMT followed by a possible
* wrapped hexdump and a final LF. */
void
_gpgrt_logv_printhex (const void *buffer, size_t length,
const char *fmt, va_list arg_ptr)
{
int wrap = 0;
int cnt = 0;
const unsigned char *p;
/* FIXME: This printing is not yet protected by _gpgrt_flockfile. */
if (fmt && *fmt)
{
_gpgrt_logv_internal (GPGRT_LOGLVL_DEBUG, 0, NULL, NULL, fmt, arg_ptr);
wrap = 1;
}
if (length)
{
if (wrap)
_gpgrt_log_printf (" ");
for (p = buffer; length--; p++)
{
_gpgrt_log_printf ("%02x", *p);
if (wrap && ++cnt == 32 && length)
{
cnt = 0;
/* (we indicate continuations with a backslash) */
_gpgrt_log_printf (" \\\n");
_gpgrt_log_debug ("%s", "");
if (fmt && *fmt)
_gpgrt_log_printf (" ");
}
}
}
if (fmt)
_gpgrt_log_printf ("\n");
}
/* Print a hexdump of (BUFFER,LENGTH). With FMT passed as NULL print
* just the raw dump, with FMT being an empty string, print a trailing
* linefeed, otherwise print an entire debug line with the expanded
* FMT followed by the hexdump and a final LF. */
void
_gpgrt_log_printhex (const void *buffer, size_t length,
const char *fmt, ...)
{
va_list arg_ptr;
if (fmt)
{
va_start (arg_ptr, fmt);
_gpgrt_logv_printhex (buffer, length, fmt, arg_ptr);
va_end (arg_ptr);
}
else
{
/* va_list is not necessary a pointer and thus we can't use NULL
* because that would conflict with platforms using a straight
* struct for it (e.g. arm64). We use a dummy variable instead;
* the static is a simple way zero it out so to not get
* complains about uninitialized use. */
static va_list dummy_argptr;
_gpgrt_logv_printhex (buffer, length, NULL, dummy_argptr);
}
}
/* Print a microsecond timestamp followed by FMT. */
void
_gpgrt_logv_clock (const char *fmt, va_list arg_ptr)
{
#if ENABLE_LOG_CLOCK
static unsigned long long initial;
struct timespec tv;
unsigned long long now;
char clockbuf[50];
if (clock_gettime (CLOCK_REALTIME, &tv))
{
_gpgrt_log_debug ("error getting the realtime clock value\n");
return;
}
now = tv.tv_sec * 1000000000ull;
now += tv.tv_nsec;
if (!initial)
initial = now;
snprintf (clockbuf, sizeof clockbuf, "[%6llu] ", (now - initial)/1000);
_gpgrt_logv_internal (GPGRT_LOGLVL_DEBUG, 0, NULL, clockbuf, fmt, arg_ptr);
#else /*!ENABLE_LOG_CLOCK*/
/* You may need to link with -ltr to use the above code. */
_gpgrt_logv_internal (GPGRT_LOGLVL_DEBUG,
0, NULL, "[no clock] ", fmt, arg_ptr);
#endif /*!ENABLE_LOG_CLOCK*/
}
/* Print a microsecond timestamp followed by FMT. */
void
_gpgrt_log_clock (const char *fmt, ...)
{
va_list arg_ptr;
va_start (arg_ptr, fmt);
_gpgrt_logv_clock (fmt, arg_ptr);
va_end (arg_ptr);
}
void
_gpgrt__log_assert (const char *expr, const char *file,
int line, const char *func)
{
#ifdef GPGRT_HAVE_MACRO_FUNCTION
_gpgrt_log (GPGRT_LOGLVL_BUG, "Assertion \"%s\" in %s failed (%s:%d)\n",
expr, func, file, line);
#else /*!GPGRT_HAVE_MACRO_FUNCTION*/
_gpgrt_log (GPGRT_LOGLVL_BUG, "Assertion \"%s\" failed (%s:%d)\n",
expr, file, line);
#endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
_gpgrt_abort (); /* Never called; just to make the compiler happy. */
}
diff --git a/src/mkheader.c b/src/mkheader.c
index 1d2ea20..154d79f 100644
--- a/src/mkheader.c
+++ b/src/mkheader.c
@@ -1,780 +1,787 @@
/* mkheader.c - Create a header file for libgpg-error
* Copyright (C) 2010 Free Software Foundation, Inc.
* Copyright (C) 2014 g10 Code GmbH
*
* This file is free software; as a special exception the author gives
* unlimited permission to copy and/or distribute it, with or without
* modifications, as long as this notice is preserved.
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include
#include
#include
#include
#include
#define PGM "mkheader"
#define LINESIZE 1024
static char *host_triplet; /* malloced. */
static char *host_os; /* points into host_triplet. */
static char *srcdir;
static const char *hdr_version;
static const char *hdr_version_number;
static int cross_building; /* Command line flag. */
/* Values take from the supplied config.h. */
static int have_stdint_h;
static int have_sys_types_h;
static int have_w32_system;
static int have_w64_system;
static char *replacement_for_off_type;
static int use_posix_threads;
/* Various state flags. */
static int stdint_h_included;
static int sys_types_h_included;
/* The usual free wrapper. */
static void
xfree (void *a)
{
if (a)
free (a);
}
static char *
xmalloc (size_t n)
{
char *p;
p = malloc (n);
if (!p)
{
fputs (PGM ": out of core\n", stderr);
exit (1);
}
return p;
}
static char *
xstrdup (const char *string)
{
char *p;
size_t len = strlen (string) + 1;
p = xmalloc (len);
memcpy (p, string, len);
return p;
}
/* Return a malloced string with TRIPLET. If TRIPLET has an alias
* return that instead. In general build-aux/config.sub should do the
* aliasing but some returned triplets are anyway identical and thus
* we use this function to map it to the canonical form. A pointer to
* the OS part of the returned value is stored at R_OS.
* NO_VENDOR_HACK is for internal use; caller must call with 0. */
static char *
canon_host_triplet (const char *triplet, int no_vendor_hack, char **r_os)
{
struct {
const char *name;
const char *alias;
} tbl[] = {
{"i486-pc-linux-gnu", "i686-unknown-linux-gnu" },
{"i586-pc-linux-gnu" },
{"i686-pc-linux-gnu" },
{"arc-oe-linux-gnu" }, /* Other CPU but same struct. */
{"arc-oe-linux-uclibc" }, /* and uclibc is also the same. */
{"i486-pc-gnu", "i686-unknown-gnu"},
{"i586-pc-gnu"},
{"i686-pc-gnu"},
{"i486-pc-kfreebsd-gnu", "i686-unknown-kfreebsd-gnu"},
{"i586-pc-kfreebsd-gnu"},
{"i686-pc-kfreebsd-gnu"},
{"x86_64-pc-linux-gnuhardened1", "x86_64-unknown-linux-gnu" },
{"x86_64-pc-linux-gnu" },
{"powerpc-unknown-linux-gnuspe", "powerpc-unknown-linux-gnu" },
{"arm-unknown-linux-gnueabihf", "arm-unknown-linux-gnueabi" },
{"armv7-unknown-linux-gnueabihf" },
{"armv7a-unknown-linux-gnueabihf" },
{"armv5-unknown-linux-musleabi" },
{"armv6-unknown-linux-musleabihf" },
{ NULL }
};
int i;
const char *lastalias = NULL;
const char *s;
char *p;
char *result;
for (i=0; tbl[i].name; i++)
{
if (tbl[i].alias)
lastalias = tbl[i].alias;
if (!strcmp (tbl[i].name, triplet))
{
if (!lastalias)
break; /* Ooops: first entry has no alias. */
result = xstrdup (lastalias);
goto leave;
}
}
for (i=0, s=triplet; *s; s++)
if (*s == '-')
i++;
if (i > 2 && !no_vendor_hack)
{
/* We have a 4 part "triplet": CPU-VENDOR-KERNEL-SYSTEM where
* the last two parts replace the OS part of a real triplet.
* The VENDOR part is then in general useless because
* KERNEL-SYSTEM is specific enough. We now do a second pass by
* replacing VENDOR with "unknown". */
char *buf = xmalloc (strlen (triplet) + 7 + 1);
for (p=buf,s=triplet,i=0; *s; s++)
{
*p++ = *s;
if (*s == '-' && ++i == 1)
{
memcpy (p, "unknown-",8);
p += 8;
for (s++; *s != '-'; s++)
;
}
}
*p = 0;
result = canon_host_triplet (buf, 1, NULL);
xfree (buf);
goto leave;
}
result = xstrdup (triplet);
leave:
/* Find the OS part. */
if (r_os)
{
*r_os = result + strlen (result); /* Default to the empty string. */
for (i=0, p=result; *p; p++)
if (*p == '-' && ++i == 2)
{
*r_os = p+1;
break;
}
}
return result;
}
/* Parse the supplied config.h file and extract required info.
Returns 0 on success. */
static int
parse_config_h (const char *fname)
{
FILE *fp;
char line[LINESIZE];
int lnr = 0;
char *p1;
fp = fopen (fname, "r");
if (!fp)
{
fprintf (stderr, "%s:%d: can't open file: %s\n",
fname, lnr, strerror (errno));
return 1;
}
while (fgets (line, LINESIZE, fp))
{
size_t n = strlen (line);
lnr++;
if (!n || line[n-1] != '\n')
{
fprintf (stderr,
"%s:%d: trailing linefeed missing, line too long or "
"embedded nul character\n", fname, lnr);
break;
}
line[--n] = 0;
if (strncmp (line, "#define ", 8))
continue; /* We are only interested in define lines. */
p1 = strtok (line + 8, " \t");
if (!*p1)
continue; /* oops */
if (!strcmp (p1, "HAVE_STDINT_H"))
have_stdint_h = 1;
else if (!strcmp (p1, "HAVE_SYS_TYPES_H"))
have_sys_types_h = 1;
else if (!strcmp (p1, "HAVE_W32_SYSTEM"))
have_w32_system = 1;
else if (!strcmp (p1, "HAVE_W64_SYSTEM"))
have_w64_system = 1;
else if (!strcmp (p1, "REPLACEMENT_FOR_OFF_T"))
{
p1 = strtok (NULL, "\"");
if (!*p1)
continue; /* oops */
xfree (replacement_for_off_type);
replacement_for_off_type = xstrdup (p1);
}
else if (!strcmp (p1, "USE_POSIX_THREADS"))
use_posix_threads = 1;
}
if (ferror (fp))
{
fprintf (stderr, "%s:%d: error reading file: %s\n",
fname, lnr, strerror (errno));
fclose (fp);
return 1;
}
fclose (fp);
return 0;
}
/* Write LINE to stdout. The function is allowed to modify LINE. */
static void
write_str (char *line)
{
if (fputs (line, stdout) == EOF)
{
fprintf (stderr, PGM ": error writing to stdout: %s\n", strerror (errno));
exit (1);
}
}
static void
write_line (char *line)
{
if (puts (line) == EOF)
{
fprintf (stderr, PGM ": error writing to stdout: %s\n", strerror (errno));
exit (1);
}
}
/* Write SOURCE or CODES line to stdout. The function is allowed to
modify LINE. Trailing white space is already removed. Passing
NULL resets the internal state. */
static void
write_sources_or_codes (char *line)
{
static int in_intro;
char *p1, *p2;
if (!line)
{
in_intro = 1;
return;
}
if (!*line)
return;
if (in_intro)
{
if (!strchr ("0123456789", *line))
return;
in_intro = 0;
}
p1 = strtok (line, " \t");
p2 = p1? strtok (NULL, " \t") : NULL;
if (p1 && p2 && strchr ("0123456789", *p1) && *p2)
{
write_str (" ");
write_str (p2);
write_str (" = ");
write_str (p1);
write_str (",\n");
}
}
/* Write system errnos to stdout. The function is allowed to
modify LINE. Trailing white space is already removed. Passing
NULL resets the internal state. */
static void
write_errnos_in (char *line)
{
static int state;
char *p1, *p2;
if (!line)
{
state = 0;
return;
}
if (!*line)
return;
if (!state && strchr ("0123456789", *line))
state = 1;
else if (state == 1 && !strchr ("0123456789", *line))
state = 2;
if (state != 1)
return;
p1 = strtok (line, " \t");
p2 = p1? strtok (NULL, " \t") : NULL;
if (p1 && p2 && strchr ("0123456789", *p1) && *p2)
{
write_str (" GPG_ERR_");
write_str (p2);
write_str (" = GPG_ERR_SYSTEM_ERROR | ");
write_str (p1);
write_str (",\n");
}
}
/* Create the full file name for NAME and return a newly allocated
string with it. If name contains a '&' and REPL is not NULL
replace '&' with REPL. */
static char *
mk_include_name (const char *name, const char *repl)
{
FILE *fp;
char *incfname, *p;
const char *s;
incfname = malloc (strlen (srcdir) + strlen (name)
+ (repl?strlen (repl):0) + 1);
if (!incfname)
{
fputs (PGM ": out of core\n", stderr);
exit (1);
}
if (*name == '.' && name[1] == '/')
*incfname = 0;
else
strcpy (incfname, srcdir);
p = incfname + strlen (incfname);
for (s=name; *s; s++)
{
if (*s == '&' && repl)
{
while (*repl)
*p++ = *repl++;
repl = NULL; /* Replace only once. */
}
else
*p++ = *s;
}
*p = 0;
return incfname;
}
/* Include the file NAME from the source directory. The included file
is not further expanded. It may have comments indicated by a
double hash mark at the begin of a line. OUTF is called for each
read line and passed a buffer with the content of line sans line
line endings. If NAME is prefixed with "./" it is included from
the current directory and not from the source directory. */
static void
include_file (const char *fname, int lnr, const char *name, void (*outf)(char*))
{
FILE *fp;
char *incfname;
int inclnr;
char line[LINESIZE];
int repl_flag;
repl_flag = !!strchr (name, '&');
incfname = mk_include_name (name, repl_flag? host_triplet : NULL);
fp = fopen (incfname, "r");
if (!fp && repl_flag)
{
/* Try again using the OS string. */
free (incfname);
incfname = mk_include_name (name, host_os);
fp = fopen (incfname, "r");
}
if (!fp)
{
fprintf (stderr, "%s:%d: error including `%s': %s\n",
fname, lnr, incfname, strerror (errno));
exit (1);
}
if (repl_flag)
fprintf (stderr,"%s:%d: note: including '%s'\n",
fname, lnr, incfname);
inclnr = 0;
while (fgets (line, LINESIZE, fp))
{
size_t n = strlen (line);
inclnr++;
if (!n || line[n-1] != '\n')
{
fprintf (stderr,
"%s:%d: trailing linefeed missing, line too long or "
"embedded nul character\n", incfname, inclnr);
fprintf (stderr,"%s:%d: note: file '%s' included from here\n",
fname, lnr, incfname);
exit (1);
}
line[--n] = 0;
while (line[n] == ' ' || line[n] == '\t' || line[n] == '\r')
{
line[n] = 0;
if (!n)
break;
n--;
}
if (line[0] == '#' && line[1] == '#')
{
if (!strncmp (line+2, "EOF##", 5))
break; /* Forced EOF. */
}
else
outf (line);
}
if (ferror (fp))
{
fprintf (stderr, "%s:%d: error reading `%s': %s\n",
fname, lnr, incfname, strerror (errno));
exit (1);
}
fclose (fp);
free (incfname);
}
/* Try to include the file NAME. Returns true if it does not
exist. */
static int
try_include_file (const char *fname, int lnr, const char *name,
void (*outf)(char*))
{
int rc;
char *incfname;
int repl_flag;
repl_flag = !!strchr (name, '&');
incfname = mk_include_name (name, repl_flag? host_triplet : NULL);
rc = access (incfname, R_OK);
if (rc && repl_flag)
{
free (incfname);
incfname = mk_include_name (name, host_os);
rc = access (incfname, R_OK);
}
if (!rc)
include_file (fname, lnr, name, outf);
free (incfname);
return rc;
}
static int
write_special (const char *fname, int lnr, const char *tag)
{
if (!strcmp (tag, "version"))
{
putchar ('\"');
fputs (hdr_version, stdout);
putchar ('\"');
}
else if (!strcmp (tag, "version-number"))
{
fputs (hdr_version_number, stdout);
}
else if (!strcmp (tag, "define:gpgrt_off_t"))
{
if (!replacement_for_off_type)
{
fprintf (stderr, "%s:%d: replacement for off_t not defined\n",
fname, lnr);
exit (1);
}
else
{
if (!strcmp (replacement_for_off_type, "int64_t")
&& !stdint_h_included && have_stdint_h)
{
fputs ("#include \n\n", stdout);
stdint_h_included = 1;
}
printf ("typedef %s gpgrt_off_t;\n", replacement_for_off_type);
}
}
else if (!strcmp (tag, "define:gpgrt_ssize_t"))
{
if (have_w64_system)
{
if (!stdint_h_included && have_stdint_h)
{
fputs ("# include \n", stdout);
stdint_h_included = 1;
}
fputs ("typedef int64_t gpgrt_ssize_t;\n", stdout);
}
else if (have_w32_system)
{
fputs ("typedef long gpgrt_ssize_t;\n", stdout);
}
else
{
if (!sys_types_h_included)
{
fputs ("#include \n", stdout);
sys_types_h_included = 1;
}
fputs ("typedef ssize_t gpgrt_ssize_t;\n", stdout);
}
}
else if (!strcmp (tag, "api_ssize_t"))
{
if (have_w32_system)
fputs ("gpgrt_ssize_t", stdout);
else
fputs ("ssize_t", stdout);
}
+ else if (!strcmp (tag, "SOCKET_t"))
+ {
+ if (have_w32_system)
+ fputs ("uintptr_t", stdout);
+ else
+ fputs ("int", stdout);
+ }
else if (!strcmp (tag, "define:pid_t"))
{
if (have_sys_types_h)
{
if (!sys_types_h_included)
{
fputs ("#include \n", stdout);
sys_types_h_included = 1;
}
}
else if (have_w64_system)
{
if (!stdint_h_included && have_stdint_h)
{
fputs ("#include \n", stdout);
stdint_h_included = 1;
}
fputs ("typedef int64_t pid_t\n", stdout);
}
else
{
fputs ("typedef int pid_t\n", stdout);
}
}
else if (!strcmp (tag, "include:err-sources"))
{
write_sources_or_codes (NULL);
include_file (fname, lnr, "err-sources.h.in", write_sources_or_codes);
}
else if (!strcmp (tag, "include:err-codes"))
{
write_sources_or_codes (NULL);
include_file (fname, lnr, "err-codes.h.in", write_sources_or_codes);
}
else if (!strcmp (tag, "include:errnos"))
{
include_file (fname, lnr, "errnos.in", write_errnos_in);
}
else if (!strcmp (tag, "include:os-add"))
{
if (!strcmp (host_os, "mingw32"))
{
include_file (fname, lnr, "w32-add.h", write_line);
}
else if (!strcmp (host_os, "mingw32ce"))
{
include_file (fname, lnr, "w32-add.h", write_line);
include_file (fname, lnr, "w32ce-add.h", write_line);
}
}
else if (!strcmp (tag, "include:lock-obj"))
{
/* If we are not cross compiling and the native file exists we
* prefer that over one from syscfg. */
if (cross_building
|| try_include_file (fname, lnr,
"./lock-obj-pub.native.h", write_line))
include_file (fname, lnr, "syscfg/lock-obj-pub.&.h", write_line);
}
else
return 0; /* Unknown tag. */
return 1; /* Tag processed. */
}
int
main (int argc, char **argv)
{
FILE *fp = NULL;
char line[LINESIZE];
int lnr = 0;
const char *fname, *s;
char *p1, *p2;
const char *config_h;
const char *host_triplet_raw;
if (argc)
{
argc--; argv++;
}
if (argc && !strcmp (argv[0], "--cross"))
{
cross_building = 1;
argc--; argv++;
}
if (argc == 1)
{
/* Print just the canonicalized host triplet. */
host_triplet = canon_host_triplet (argv[0], 0, &host_os);
printf ("%s\n", host_triplet);
goto leave;
}
else if (argc == 5)
; /* Standard operation. */
else
{
fputs ("usage: " PGM
" host_triplet template.h config.h version version_number\n"
" " PGM
" host_triplet\n",
stderr);
return 1;
}
host_triplet_raw = argv[0];
fname = argv[1];
config_h = argv[2];
hdr_version = argv[3];
hdr_version_number = argv[4];
host_triplet = canon_host_triplet (host_triplet_raw, 0, &host_os);
srcdir = malloc (strlen (fname) + 2 + 1);
if (!srcdir)
{
fputs (PGM ": out of core\n", stderr);
return 1;
}
strcpy (srcdir, fname);
p1 = strrchr (srcdir, '/');
if (p1)
p1[1] = 0;
else
strcpy (srcdir, "./");
if (parse_config_h (config_h))
return 1;
fp = fopen (fname, "r");
if (!fp)
{
fprintf (stderr, "%s:%d: can't open file: %s\n",
fname, lnr, strerror (errno));
return 1;
}
while (fgets (line, LINESIZE, fp))
{
size_t n = strlen (line);
lnr++;
if (!n || line[n-1] != '\n')
{
fprintf (stderr,
"%s:%d: trailing linefeed missing, line too long or "
"embedded nul character\n", fname, lnr);
break;
}
line[--n] = 0;
p1 = strchr (line, '@');
p2 = p1? strchr (p1+1, '@') : NULL;
if (!p1 || !p2 || p2-p1 == 1)
{
puts (line);
continue;
}
*p1++ = 0;
*p2++ = 0;
fputs (line, stdout);
if (!strcmp (p1, "configure_input"))
{
s = strrchr (fname, '/');
printf ("Do not edit. Generated from %s for:\n%*s",
s? s+1 : fname, (int)(p1 - line) + 13, "");
if (!strcmp (host_triplet, host_triplet_raw))
printf ("%s", host_triplet);
else
printf ("%s (%s)", host_triplet, host_triplet_raw);
if (!use_posix_threads && !have_w32_system && !have_w64_system)
fputs (" NO-THREADS", stdout);
fputs (p2, stdout);
}
else if (!write_special (fname, lnr, p1))
{
putchar ('@');
fputs (p1, stdout);
putchar ('@');
fputs (p2, stdout);
}
else if (*p2)
{
fputs (p2, stdout);
}
putchar ('\n');
}
if (ferror (fp))
{
fprintf (stderr, "%s:%d: error reading file: %s\n",
fname, lnr, strerror (errno));
return 1;
}
fputs ("/*\n"
"Loc" "al Variables:\n"
"buffer-read-only: t\n"
"End:\n"
"*/\n", stdout);
leave:
if (ferror (stdout))
{
fprintf (stderr, PGM ": error writing to stdout: %s\n", strerror (errno));
return 1;
}
if (fp)
fclose (fp);
xfree (host_triplet);
return 0;
}
diff --git a/src/posix-lock.c b/src/posix-lock.c
index d0fd07a..85ec660 100644
--- a/src/posix-lock.c
+++ b/src/posix-lock.c
@@ -1,266 +1,300 @@
/* posix-lock.c - GPGRT lock functions for POSIX systems
Copyright (C) 2005-2009 Free Software Foundation, Inc.
Copyright (C) 2014 g10 Code GmbH
This file is part of libgpg-error.
libgpg-error 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.
libgpg-error 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 this program; if not, see .
Parts of the code, in particular use_pthreads_p, are based on code
from gettext, written by Bruno Haible , 2005.
*/
#if HAVE_CONFIG_H
#include
#endif
#ifdef HAVE_W32_SYSTEM
# error This module may not be build for Windows.
#endif
#include
#include
#include
#include
#if USE_POSIX_THREADS
# include
#endif
#include "gpgrt-int.h"
#include "lock.h"
#include "posix-lock-obj.h"
#if USE_POSIX_THREADS
# if USE_POSIX_THREADS_FROM_LIBC && HAVE_SYS_SINGLE_THREADED_H
# include
# define use_pthread_p() !__libc_single_threaded
# elif USE_POSIX_THREADS_WEAK
/* On ELF systems it is easy to use pthreads using weak
references. Take care not to test the address of a weak
referenced function we actually use; some GCC versions have a
bug were &foo != NULL is always evaluated to true in PIC mode. */
# pragma weak pthread_cancel
# pragma weak pthread_mutex_init
# pragma weak pthread_mutex_lock
# pragma weak pthread_mutex_trylock
# pragma weak pthread_mutex_unlock
# pragma weak pthread_mutex_destroy
# if ! PTHREAD_IN_USE_DETECTION_HARD
# define use_pthread_p() (!!pthread_cancel)
# endif
# else /*!USE_POSIX_THREADS_WEAK*/
# if ! PTHREAD_IN_USE_DETECTION_HARD
# define use_pthread_p() (1)
# endif
# endif /*!USE_POSIX_THREADS_WEAK*/
# if PTHREAD_IN_USE_DETECTION_HARD
+# if defined __FreeBSD__ || defined __DragonFly__ /* FreeBSD */
+
+/* Test using pthread_key_create. */
+
+static int
+use_pthread_p (void)
+{
+ static int tested;
+ static int result; /* 1: linked with -lpthread, 0: only with libc */
+
+ if (!tested)
+ {
+ pthread_key_t key;
+ int err = pthread_key_create (&key, NULL);
+
+ if (err == ENOSYS)
+ result = 0;
+ else
+ {
+ result = 1;
+ if (err == 0)
+ pthread_key_delete (key);
+ }
+ tested = 1;
+ }
+ return result;
+}
+
+# else /* Solaris, HP-UX */
+
+/* Test using pthread_create. */
+
/* The function to be executed by a dummy thread. */
static void *
dummy_thread_func (void *arg)
{
return arg;
}
static int
use_pthread_p (void)
{
static int tested;
static int result; /* 1: linked with -lpthread, 0: only with libc */
if (!tested)
{
pthread_t thread;
- if (pthread_create (&thread, NULL, dummy_thread_func, NULL))
+ if (pthread_create (&thread, NULL, dummy_thread_func, NULL) != 0)
result = 0; /* Thread creation failed. */
else
{
/* Thread creation works. */
void *retval;
if (pthread_join (thread, &retval) != 0)
{
fputs ("gpgrt fatal: pthread_join in use_pthread_p failed\n",
stderr);
_gpgrt_abort ();
}
result = 1;
}
tested = 1;
}
return result;
}
+# endif /* Solaris, HP-UX */
+
# endif /*PTHREAD_IN_USE_DETECTION_HARD*/
#endif /*USE_POSIX_THREADS*/
static _gpgrt_lock_t *
get_lock_object (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = (_gpgrt_lock_t*)lockhd;
if (lock->vers != LOCK_ABI_VERSION)
{
fputs ("gpgrt fatal: lock ABI version mismatch\n", stderr);
_gpgrt_abort ();
}
if (sizeof (gpgrt_lock_t) < sizeof (_gpgrt_lock_t))
{
fputs ("gpgrt fatal: sizeof lock obj\n", stderr);
_gpgrt_abort ();
}
return lock;
}
gpg_err_code_t
_gpgrt_lock_init (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = (_gpgrt_lock_t*)lockhd;
int rc;
/* If VERS is zero we assume that no static initialization has been
done, so we setup our ABI version right here. The caller might
have called us to test whether lock support is at all available. */
if (!lock->vers)
{
if (sizeof (gpgrt_lock_t) < sizeof (_gpgrt_lock_t))
{
fputs ("gpgrt fatal: sizeof lock obj\n", stderr);
_gpgrt_abort ();
}
lock->vers = LOCK_ABI_VERSION;
}
else /* Run the usual check. */
lock = get_lock_object (lockhd);
#if USE_POSIX_THREADS
if (use_pthread_p())
{
rc = pthread_mutex_init (&lock->u.mtx, NULL);
if (rc)
rc = _gpg_err_code_from_errno (rc);
}
else
rc = 0; /* Threads are not used. */
#else /* Unknown thread system. */
rc = lock->vers == LOCK_ABI_NOT_AVAILABLE? 0 : GPG_ERR_NOT_IMPLEMENTED;
#endif /* Unknown thread system. */
return rc;
}
gpg_err_code_t
_gpgrt_lock_lock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
int rc;
#if USE_POSIX_THREADS
if (use_pthread_p())
{
_gpgrt_pre_syscall ();
rc = pthread_mutex_lock (&lock->u.mtx);
if (rc)
rc = _gpg_err_code_from_errno (rc);
_gpgrt_post_syscall ();
}
else
rc = 0; /* Threads are not used. */
#else /* Unknown thread system. */
rc = lock->vers == LOCK_ABI_NOT_AVAILABLE? 0 : GPG_ERR_NOT_IMPLEMENTED;
#endif /* Unknown thread system. */
return rc;
}
gpg_err_code_t
_gpgrt_lock_trylock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
int rc;
#if USE_POSIX_THREADS
if (use_pthread_p())
{
rc = pthread_mutex_trylock (&lock->u.mtx);
if (rc)
rc = _gpg_err_code_from_errno (rc);
}
else
rc = 0; /* Threads are not used. */
#else /* Unknown thread system. */
rc = lock->vers == LOCK_ABI_NOT_AVAILABLE? 0 : GPG_ERR_NOT_IMPLEMENTED;
#endif /* Unknown thread system. */
return rc;
}
gpg_err_code_t
_gpgrt_lock_unlock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
int rc;
#if USE_POSIX_THREADS
if (use_pthread_p())
{
rc = pthread_mutex_unlock (&lock->u.mtx);
if (rc)
rc = _gpg_err_code_from_errno (rc);
}
else
rc = 0; /* Threads are not used. */
#else /* Unknown thread system. */
rc = lock->vers == LOCK_ABI_NOT_AVAILABLE? 0 : GPG_ERR_NOT_IMPLEMENTED;
#endif /* Unknown thread system. */
return rc;
}
/* Note: Use this function only if no other thread holds or waits for
this lock. */
gpg_err_code_t
_gpgrt_lock_destroy (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
int rc;
#if USE_POSIX_THREADS
if (use_pthread_p())
{
rc = pthread_mutex_destroy (&lock->u.mtx);
if (rc)
rc = _gpg_err_code_from_errno (rc);
else
{
/* Re-init the mutex so that it can be re-used. */
gpgrt_lock_t tmp = GPGRT_LOCK_INITIALIZER;
memcpy (lockhd, &tmp, sizeof tmp);
}
}
else
rc = 0; /* Threads are not used. */
#else /* Unknown thread system. */
rc = lock->vers == LOCK_ABI_NOT_AVAILABLE? 0 : GPG_ERR_NOT_IMPLEMENTED;
#endif /* Unknown thread system. */
return rc;
}
diff --git a/src/spawn-w32.c b/src/spawn-w32.c
index 3ede1f2..1b5f085 100644
--- a/src/spawn-w32.c
+++ b/src/spawn-w32.c
@@ -1,920 +1,923 @@
/* spawn-w32.c - Fork and exec helpers for W32.
* Copyright (C) 2004, 2007-2009, 2010 Free Software Foundation, Inc.
* Copyright (C) 2004, 2006-2012, 2014-2017 g10 Code GmbH
*
* This file is part of Libgpg-error.
*
* Libgpg-error 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.
*
* Libgpg-error 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 this program; if not, see .
* SPDX-License-Identifier: LGPL-2.1+
*
* This file was originally a part of GnuPG.
*/
#include
#if !defined(HAVE_W32_SYSTEM) || defined (HAVE_W32CE_SYSTEM)
#error This code is only used on W32.
#endif
#include
#include
#include
#include
#ifdef HAVE_SIGNAL_H
# include
#endif
#include
#include
#ifdef HAVE_STAT
# include
#endif
#define WIN32_LEAN_AND_MEAN /* We only need the OS core stuff. */
#include
#include "gpgrt-int.h"
/* Define to 1 do enable debugging. */
#define DEBUG_W32_SPAWN 0
/* It seems Vista doesn't grok X_OK and so fails access() tests.
* Previous versions interpreted X_OK as F_OK anyway, so we'll just
* use F_OK directly. */
#undef X_OK
#define X_OK F_OK
/* For HANDLE and the internal file descriptor (fd) of this module:
* HANDLE can be represented by an intptr_t which should be true for
* all systems (HANDLE is defined as void *). Further, we assume that
* -1 denotes an invalid handle.
*
* Note that a C run-time file descriptor (the exposed one to API) is
* always represented by an int.
*/
#define fd_to_handle(a) ((HANDLE)(a))
#define handle_to_fd(a) ((intptr_t)(a))
/* For pid_t and HANDLE:
* We assume that a HANDLE can be represented by an int which should
* be true for all i386 systems.
*
* On 64-bit machine, it is no longer true, as a type, however, as
* long as the range of the value in the type HANDLE can be
* represented by an int, it works.
*
- * FIXME: Breaking ABI for pid_t will be needed when the value won't
- * fit within 32-bit range on 64-bit machine.
+ * FIXME with original MinGW: Breaking ABI for pid_t will be needed
+ * when the value won't fit within 32-bit range on 64-bit machine.
+ *
+ * Note that pid_t is 64-bit integer in sys/types.h with MinGW-w64.
+ * So, no problem with MinGW-w64.
*/
#define pid_to_handle(a) ((HANDLE)(a))
-#define handle_to_pid(a) ((int)(a))
+#define handle_to_pid(a) ((pid_t)(a))
/* Return the maximum number of currently allowed open file
* descriptors. Only useful on POSIX systems but returns a value on
* other systems too. */
int
get_max_fds (void)
{
int max_fds = -1;
#ifdef OPEN_MAX
if (max_fds == -1)
max_fds = OPEN_MAX;
#endif
if (max_fds == -1)
max_fds = 256; /* Arbitrary limit. */
return max_fds;
}
/* Under Windows this is a dummy function. */
/* static void */
/* close_all_fds (int first, int *except) */
/* { */
/* (void)first; */
/* (void)except; */
/* } */
/* Returns an array with all currently open file descriptors. The end
* of the array is marked by -1. The caller needs to release this
* array using the *standard free* and not with xfree. This allow the
* use of this function right at startup even before libgcrypt has
* been initialized. Returns NULL on error and sets ERRNO
* accordingly. Note that fstat prints a warning to DebugView for all
* invalid fds which is a bit annoying. We actually do not need this
* function in real code (close_all_fds is a dummy anyway) but we keep
* it for use by t-exechelp.c. */
#if 0
int *
get_all_open_fds (void)
{
int *array;
size_t narray;
int fd, max_fd, idx;
#ifndef HAVE_STAT
array = calloc (1, sizeof *array);
if (array)
array[0] = -1;
#else /*HAVE_STAT*/
struct stat statbuf;
max_fd = get_max_fds ();
narray = 32; /* If you change this change also t-exechelp.c. */
array = calloc (narray, sizeof *array);
if (!array)
return NULL;
/* Note: The list we return is ordered. */
for (idx=0, fd=0; fd < max_fd; fd++)
if (!(fstat (fd, &statbuf) == -1 && errno == EBADF))
{
if (idx+1 >= narray)
{
int *tmp;
narray += (narray < 256)? 32:256;
tmp = realloc (array, narray * sizeof *array);
if (!tmp)
{
free (array);
return NULL;
}
array = tmp;
}
array[idx++] = fd;
}
array[idx] = -1;
#endif /*HAVE_STAT*/
return array;
}
#endif
/* Helper function to build_w32_commandline. */
static char *
build_w32_commandline_copy (char *buffer, const char *string)
{
char *p = buffer;
const char *s;
if (!*string) /* Empty string. */
p = stpcpy (p, "\"\"");
else if (strpbrk (string, " \t\n\v\f\""))
{
/* Need to do some kind of quoting. */
p = stpcpy (p, "\"");
for (s=string; *s; s++)
{
*p++ = *s;
if (*s == '\"')
*p++ = *s;
}
*p++ = '\"';
*p = 0;
}
else
p = stpcpy (p, string);
return p;
}
/* Build a command line for use with W32's CreateProcess. On success
* CMDLINE gets the address of a newly allocated string. */
static gpg_err_code_t
build_w32_commandline (const char *pgmname, const char * const *argv,
char **cmdline)
{
int i, n;
const char *s;
char *buf, *p;
*cmdline = NULL;
n = 0;
s = pgmname;
n += strlen (s) + 1 + 2; /* (1 space, 2 quoting */
for (; *s; s++)
if (*s == '\"')
n++; /* Need to double inner quotes. */
for (i=0; (s=argv[i]); i++)
{
n += strlen (s) + 1 + 2; /* (1 space, 2 quoting */
for (; *s; s++)
if (*s == '\"')
n++; /* Need to double inner quotes. */
}
n++;
buf = p = xtrymalloc (n);
if (!buf)
return _gpg_err_code_from_syserror ();
p = build_w32_commandline_copy (p, pgmname);
for (i=0; argv[i]; i++)
{
*p++ = ' ';
p = build_w32_commandline_copy (p, argv[i]);
}
*cmdline= buf;
return 0;
}
#define INHERIT_READ 1
#define INHERIT_WRITE 2
#define INHERIT_BOTH (INHERIT_READ|INHERIT_WRITE)
/* Create pipe. FLAGS indicates which ends are inheritable. */
static int
create_inheritable_pipe (HANDLE filedes[2], int flags)
{
HANDLE r, w;
SECURITY_ATTRIBUTES sec_attr;
memset (&sec_attr, 0, sizeof sec_attr );
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = TRUE;
_gpgrt_pre_syscall ();
if (!CreatePipe (&r, &w, &sec_attr, 0))
{
_gpgrt_post_syscall ();
return -1;
}
_gpgrt_post_syscall ();
if ((flags & INHERIT_READ) == 0)
if (! SetHandleInformation (r, HANDLE_FLAG_INHERIT, 0))
goto fail;
if ((flags & INHERIT_WRITE) == 0)
if (! SetHandleInformation (w, HANDLE_FLAG_INHERIT, 0))
goto fail;
filedes[0] = r;
filedes[1] = w;
return 0;
fail:
_gpgrt_log_error ("SetHandleInformation failed: ec=%d\n",
(int)GetLastError ());
CloseHandle (r);
CloseHandle (w);
return -1;
}
static HANDLE
w32_open_null (int for_write)
{
HANDLE hfile;
hfile = CreateFileW (L"nul",
for_write? GENERIC_WRITE : GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
if (hfile == INVALID_HANDLE_VALUE)
_gpgrt_log_debug ("can't open 'nul': ec=%d\n", (int)GetLastError ());
return hfile;
}
static gpg_err_code_t
do_create_pipe_and_estream (int filedes[2],
estream_t *r_fp, int direction, int nonblock)
{
gpg_err_code_t err = 0;
int flags;
HANDLE fds[2];
gpgrt_syshd_t syshd;
if (direction < 0)
flags = INHERIT_WRITE;
else if (direction > 0)
flags = INHERIT_READ;
else
flags = INHERIT_BOTH;
filedes[0] = filedes[1] = -1;
err = GPG_ERR_GENERAL;
if (!create_inheritable_pipe (fds, flags))
{
filedes[0] = _open_osfhandle (handle_to_fd (fds[0]), O_RDONLY);
if (filedes[0] == -1)
{
_gpgrt_log_error ("failed to translate osfhandle %p\n", fds[0]);
CloseHandle (fds[1]);
}
else
{
filedes[1] = _open_osfhandle (handle_to_fd (fds[1]), O_APPEND);
if (filedes[1] == -1)
{
_gpgrt_log_error ("failed to translate osfhandle %p\n", fds[1]);
close (filedes[0]);
filedes[0] = -1;
CloseHandle (fds[1]);
}
else
err = 0;
}
}
if (! err && r_fp)
{
syshd.type = ES_SYSHD_HANDLE;
if (direction < 0)
{
syshd.u.handle = fds[0];
*r_fp = _gpgrt_sysopen (&syshd, nonblock? "r,nonblock" : "r");
}
else
{
syshd.u.handle = fds[1];
*r_fp = _gpgrt_sysopen (&syshd, nonblock? "w,nonblock" : "w");
}
if (!*r_fp)
{
err = _gpg_err_code_from_syserror ();
_gpgrt_log_error (_("error creating a stream for a pipe: %s\n"),
_gpg_strerror (err));
close (filedes[0]);
close (filedes[1]);
filedes[0] = filedes[1] = -1;
return err;
}
}
return err;
}
/* Create a pipe. The DIRECTION parameter gives the type of the created pipe:
* DIRECTION < 0 := Inbound pipe: On Windows the write end is inheritable.
* DIRECTION > 0 := Outbound pipe: On Windows the read end is inheritable.
* If R_FP is NULL a standard pipe and no stream is created, DIRECTION
* should then be 0. */
gpg_err_code_t
_gpgrt_make_pipe (int filedes[2], estream_t *r_fp, int direction, int nonblock)
{
if (r_fp && direction)
return do_create_pipe_and_estream (filedes, r_fp, direction, nonblock);
else
return do_create_pipe_and_estream (filedes, NULL, 0, 0);
}
/* Fork and exec the PGMNAME, see gpgrt-int.h for details. */
gpg_err_code_t
_gpgrt_spawn_process (const char *pgmname, const char *argv[],
int *except, void (*preexec)(void), unsigned int flags,
estream_t *r_infp, estream_t *r_outfp, estream_t *r_errfp,
pid_t *pid)
{
gpg_err_code_t err;
SECURITY_ATTRIBUTES sec_attr;
PROCESS_INFORMATION pi =
{
NULL, /* Returns process handle. */
0, /* Returns primary thread handle. */
0, /* Returns pid. */
0 /* Returns tid. */
};
STARTUPINFO si;
int cr_flags;
char *cmdline;
HANDLE inpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
HANDLE outpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
HANDLE errpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
estream_t infp = NULL;
estream_t outfp = NULL;
estream_t errfp = NULL;
HANDLE nullhd[3] = {INVALID_HANDLE_VALUE,
INVALID_HANDLE_VALUE,
INVALID_HANDLE_VALUE};
int i;
es_syshd_t syshd;
int nonblock = !!(flags & GPGRT_SPAWN_NONBLOCK);
int ret;
(void)except; /* Not yet used. */
if (r_infp)
*r_infp = NULL;
if (r_outfp)
*r_outfp = NULL;
if (r_errfp)
*r_errfp = NULL;
- *pid = (pid_t)(-1); /* Always required. */
+ *pid = (pid_t)INVALID_HANDLE_VALUE; /* Always required. */
if (r_infp)
{
if (create_inheritable_pipe (inpipe, INHERIT_READ))
{
err = GPG_ERR_GENERAL;
_gpgrt_log_error (_("error creating a pipe: %s\n"),
_gpg_strerror (err));
return err;
}
syshd.type = ES_SYSHD_HANDLE;
syshd.u.handle = inpipe[1];
infp = _gpgrt_sysopen (&syshd, nonblock? "w,nonblock" : "w");
if (!infp)
{
err = _gpg_err_code_from_syserror ();
_gpgrt_log_error (_("error creating a stream for a pipe: %s\n"),
_gpg_strerror (err));
CloseHandle (inpipe[0]);
CloseHandle (inpipe[1]);
inpipe[0] = inpipe[1] = INVALID_HANDLE_VALUE;
return err;
}
}
if (r_outfp)
{
if (create_inheritable_pipe (outpipe, INHERIT_WRITE))
{
err = GPG_ERR_GENERAL;
_gpgrt_log_error (_("error creating a pipe: %s\n"),
_gpg_strerror (err));
return err;
}
syshd.type = ES_SYSHD_HANDLE;
syshd.u.handle = outpipe[0];
outfp = _gpgrt_sysopen (&syshd, nonblock? "r,nonblock" : "r");
if (!outfp)
{
err = _gpg_err_code_from_syserror ();
_gpgrt_log_error (_("error creating a stream for a pipe: %s\n"),
_gpg_strerror (err));
CloseHandle (outpipe[0]);
CloseHandle (outpipe[1]);
outpipe[0] = outpipe[1] = INVALID_HANDLE_VALUE;
if (infp)
_gpgrt_fclose (infp);
else if (inpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[1]);
if (inpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[0]);
return err;
}
}
if (r_errfp)
{
if (create_inheritable_pipe (errpipe, INHERIT_WRITE))
{
err = GPG_ERR_GENERAL;
_gpgrt_log_error (_("error creating a pipe: %s\n"),
_gpg_strerror (err));
return err;
}
syshd.type = ES_SYSHD_HANDLE;
syshd.u.handle = errpipe[0];
errfp = _gpgrt_sysopen (&syshd, nonblock? "r,nonblock" : "r");
if (!errfp)
{
err = _gpg_err_code_from_syserror ();
_gpgrt_log_error (_("error creating a stream for a pipe: %s\n"),
_gpg_strerror (err));
CloseHandle (errpipe[0]);
CloseHandle (errpipe[1]);
errpipe[0] = errpipe[1] = INVALID_HANDLE_VALUE;
if (outfp)
_gpgrt_fclose (outfp);
else if (outpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[0]);
if (outpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[1]);
if (infp)
_gpgrt_fclose (infp);
else if (inpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[1]);
if (inpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[0]);
return err;
}
}
/* Prepare security attributes. */
memset (&sec_attr, 0, sizeof sec_attr );
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* Build the command line. */
err = build_w32_commandline (pgmname, argv, &cmdline);
if (err)
return err;
if (inpipe[0] == INVALID_HANDLE_VALUE)
nullhd[0] = w32_open_null (0);
if (outpipe[1] == INVALID_HANDLE_VALUE)
nullhd[1] = w32_open_null (1);
if (errpipe[1] == INVALID_HANDLE_VALUE)
nullhd[2] = w32_open_null (1);
/* Start the process. Note that we can't run the PREEXEC function
because this might change our own environment. */
(void)preexec;
memset (&si, 0, sizeof si);
si.cb = sizeof (si);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
si.hStdInput = inpipe[0] == INVALID_HANDLE_VALUE? nullhd[0] : inpipe[0];
si.hStdOutput = outpipe[1] == INVALID_HANDLE_VALUE? nullhd[1] : outpipe[1];
si.hStdError = errpipe[1] == INVALID_HANDLE_VALUE? nullhd[2] : errpipe[1];
cr_flags = (CREATE_DEFAULT_ERROR_MODE
| ((flags & GPGRT_SPAWN_DETACHED)? DETACHED_PROCESS : 0)
| GetPriorityClass (GetCurrentProcess ())
| CREATE_SUSPENDED);
_gpgrt_log_debug ("CreateProcess, path='%s' cmdline='%s'\n",
pgmname, cmdline);
ret = CreateProcess (pgmname, /* Program to start. */
cmdline, /* Command line arguments. */
&sec_attr, /* Process security attributes. */
&sec_attr, /* Thread security attributes. */
TRUE, /* Inherit handles. */
cr_flags, /* Creation flags. */
NULL, /* Environment. */
NULL, /* Use current drive/directory. */
&si, /* Startup information. */
&pi /* Returns process information. */
);
if (!ret)
{
_gpgrt_log_error ("CreateProcess failed: ec=%d\n", (int)GetLastError ());
xfree (cmdline);
if (infp)
_gpgrt_fclose (infp);
else if (inpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[1]);
if (inpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[0]);
if (outfp)
_gpgrt_fclose (outfp);
else if (outpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[0]);
if (outpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[1]);
if (errfp)
_gpgrt_fclose (errfp);
else if (errpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (errpipe[0]);
if (errpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (errpipe[1]);
return GPG_ERR_GENERAL;
}
xfree (cmdline);
cmdline = NULL;
/* Close the inherited handles to /dev/null. */
for (i=0; i < DIM (nullhd); i++)
if (nullhd[i] != INVALID_HANDLE_VALUE)
CloseHandle (nullhd[i]);
/* Close the inherited ends of the pipes. */
if (inpipe[0] != INVALID_HANDLE_VALUE)
CloseHandle (inpipe[0]);
if (outpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (outpipe[1]);
if (errpipe[1] != INVALID_HANDLE_VALUE)
CloseHandle (errpipe[1]);
_gpgrt_log_debug ("CreateProcess ready: hProcess=%p hThread=%p"
" dwProcessID=%d dwThreadId=%d\n",
pi.hProcess, pi.hThread,
(int) pi.dwProcessId, (int) pi.dwThreadId);
_gpgrt_log_debug (" outfp=%p errfp=%p\n", outfp, errfp);
if ((flags & GPGRT_SPAWN_RUN_ASFW))
{
/* Fixme: For unknown reasons AllowSetForegroundWindow returns
* an invalid argument error if we pass it the correct
* processID. As a workaround we use -1 (ASFW_ANY). */
if (!AllowSetForegroundWindow (ASFW_ANY /*pi.dwProcessId*/))
_gpgrt_log_info ("AllowSetForegroundWindow() failed: ec=%d\n",
(int)GetLastError ());
}
/* Process has been created suspended; resume it now. */
_gpgrt_pre_syscall ();
ResumeThread (pi.hThread);
CloseHandle (pi.hThread);
_gpgrt_post_syscall ();
if (r_infp)
*r_infp = infp;
if (r_outfp)
*r_outfp = outfp;
if (r_errfp)
*r_errfp = errfp;
*pid = handle_to_pid (pi.hProcess);
return 0;
}
/* Fork and exec the PGMNAME using FDs, see gpgrt-int.h for details. */
gpg_err_code_t
_gpgrt_spawn_process_fd (const char *pgmname, const char *argv[],
int infd, int outfd, int errfd, pid_t *pid)
{
gpg_err_code_t err;
SECURITY_ATTRIBUTES sec_attr;
PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
STARTUPINFO si;
char *cmdline;
int ret, i;
HANDLE stdhd[3];
/* Setup return values. */
- *pid = (pid_t)(-1);
+ *pid = (pid_t)INVALID_HANDLE_VALUE;
/* Prepare security attributes. */
memset (&sec_attr, 0, sizeof sec_attr );
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* Build the command line. */
err = build_w32_commandline (pgmname, argv, &cmdline);
if (err)
return err;
memset (&si, 0, sizeof si);
si.cb = sizeof (si);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
stdhd[0] = infd == -1? w32_open_null (0) : INVALID_HANDLE_VALUE;
stdhd[1] = outfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
stdhd[2] = errfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
si.hStdInput = infd == -1? stdhd[0] : (void*)_get_osfhandle (infd);
si.hStdOutput = outfd == -1? stdhd[1] : (void*)_get_osfhandle (outfd);
si.hStdError = errfd == -1? stdhd[2] : (void*)_get_osfhandle (errfd);
_gpgrt_log_debug ("CreateProcess, path='%s' cmdline='%s'\n",
pgmname, cmdline);
ret = CreateProcess (pgmname, /* Program to start. */
cmdline, /* Command line arguments. */
&sec_attr, /* Process security attributes. */
&sec_attr, /* Thread security attributes. */
TRUE, /* Inherit handles. */
(CREATE_DEFAULT_ERROR_MODE
| GetPriorityClass (GetCurrentProcess ())
| CREATE_SUSPENDED | DETACHED_PROCESS),
NULL, /* Environment. */
NULL, /* Use current drive/directory. */
&si, /* Startup information. */
&pi /* Returns process information. */
);
if (!ret)
{
_gpgrt_log_error ("CreateProcess failed: ec=%d\n", (int)GetLastError ());
err = GPG_ERR_GENERAL;
}
else
err = 0;
xfree (cmdline);
for (i=0; i < 3; i++)
if (stdhd[i] != INVALID_HANDLE_VALUE)
CloseHandle (stdhd[i]);
if (err)
return err;
_gpgrt_log_debug ("CreateProcess ready: hProcess=%p hThread=%p"
" dwProcessID=%d dwThreadId=%d\n",
pi.hProcess, pi.hThread,
(int) pi.dwProcessId, (int) pi.dwThreadId);
/* Process has been created suspended; resume it now. */
ResumeThread (pi.hThread);
CloseHandle (pi.hThread);
*pid = handle_to_pid (pi.hProcess);
return 0;
}
/* See gpgrt-int.h for a description. */
gpg_err_code_t
_gpgrt_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
{
return _gpgrt_wait_processes (&pgmname, &pid, 1, hang, r_exitcode);
}
/* See gpgrt-int.h for a description. */
gpg_err_code_t
_gpgrt_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
int hang, int *r_exitcodes)
{
gpg_err_code_t ec = 0;
size_t i;
HANDLE *procs;
int code;
procs = xtrycalloc (count, sizeof *procs);
if (procs == NULL)
return _gpg_err_code_from_syserror ();
for (i = 0; i < count; i++)
{
if (r_exitcodes)
r_exitcodes[i] = -1;
- if (pids[i] == (pid_t)(-1))
+ if (pids[i] == (pid_t)INVALID_HANDLE_VALUE)
return GPG_ERR_INV_VALUE;
procs[i] = pid_to_handle (pids[i]);
}
_gpgrt_pre_syscall ();
code = WaitForMultipleObjects (count, procs, TRUE, hang? INFINITE : 0);
_gpgrt_post_syscall ();
switch (code)
{
case WAIT_TIMEOUT:
ec = GPG_ERR_TIMEOUT;
goto leave;
case WAIT_FAILED:
_gpgrt_log_error (_("waiting for processes to terminate failed: ec=%d\n"),
(int)GetLastError ());
ec = GPG_ERR_GENERAL;
goto leave;
case WAIT_OBJECT_0:
for (i = 0; i < count; i++)
{
DWORD exc;
if (! GetExitCodeProcess (procs[i], &exc))
{
_gpgrt_log_error (_("error getting exit code of process %d:"
" ec=%d\n"),
(int) pids[i], (int)GetLastError ());
ec = GPG_ERR_GENERAL;
}
else if (exc)
{
if (!r_exitcodes)
_gpgrt_log_error (_("error running '%s': exit status %d\n"),
pgmnames[i], (int)exc);
else
r_exitcodes[i] = (int)exc;
ec = GPG_ERR_GENERAL;
}
else
{
if (r_exitcodes)
r_exitcodes[i] = 0;
}
}
break;
default:
_gpgrt_log_debug ("WaitForMultipleObjects returned unexpected code %d\n",
code);
ec = GPG_ERR_GENERAL;
break;
}
leave:
return ec;
}
/* See gpgrt-int.h for a description. */
gpg_err_code_t
_gpgrt_spawn_process_detached (const char *pgmname, const char *argv[],
const char *envp[] )
{
gpg_err_code_t err;
SECURITY_ATTRIBUTES sec_attr;
PROCESS_INFORMATION pi =
{
NULL, /* Returns process handle. */
0, /* Returns primary thread handle. */
0, /* Returns pid. */
0 /* Returns tid. */
};
STARTUPINFO si;
int cr_flags;
char *cmdline;
int ret;
gpg_err_code_t ec;
/* We don't use ENVP. */
(void)envp;
ec = _gpgrt_access (pgmname, X_OK);
if (ec)
return ec;
/* Prepare security attributes. */
memset (&sec_attr, 0, sizeof sec_attr );
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* Build the command line. */
err = build_w32_commandline (pgmname, argv, &cmdline);
if (err)
return err;
/* Start the process. */
memset (&si, 0, sizeof si);
si.cb = sizeof (si);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
cr_flags = (CREATE_DEFAULT_ERROR_MODE
| GetPriorityClass (GetCurrentProcess ())
| CREATE_NEW_PROCESS_GROUP
| DETACHED_PROCESS);
_gpgrt_log_debug ("CreateProcess(detached), path='%s' cmdline='%s'\n",
pgmname, cmdline);
ret = CreateProcess (pgmname, /* Program to start. */
cmdline, /* Command line arguments. */
&sec_attr, /* Process security attributes. */
&sec_attr, /* Thread security attributes. */
FALSE, /* Inherit handles. */
cr_flags, /* Creation flags. */
NULL, /* Environment. */
NULL, /* Use current drive/directory. */
&si, /* Startup information. */
&pi /* Returns process information. */
);
if (!ret)
{
_gpgrt_log_error ("CreateProcess(detached) failed: ec=%d\n",
(int)GetLastError ());
xfree (cmdline);
return GPG_ERR_GENERAL;
}
xfree (cmdline);
cmdline = NULL;
_gpgrt_log_debug ("CreateProcess(detached) ready: hProcess=%p hThread=%p"
" dwProcessID=%d dwThreadId=%d\n",
pi.hProcess, pi.hThread,
(int) pi.dwProcessId, (int) pi.dwThreadId);
CloseHandle (pi.hThread);
CloseHandle (pi.hProcess);
return 0;
}
/* Kill a process; that is send an appropriate signal to the process.
gnupg_wait_process must be called to actually remove the process
from the system. An invalid PID is ignored. */
void
_gpgrt_kill_process (pid_t pid)
{
- if (pid != (pid_t) INVALID_HANDLE_VALUE)
+ if (pid != (pid_t)INVALID_HANDLE_VALUE)
{
HANDLE process = (HANDLE) pid;
/* Arbitrary error code. */
_gpgrt_pre_syscall ();
TerminateProcess (process, 1);
_gpgrt_post_syscall ();
}
}
void
_gpgrt_release_process (pid_t pid)
{
if (pid != (pid_t)INVALID_HANDLE_VALUE)
{
HANDLE process = (HANDLE)pid;
CloseHandle (process);
}
}
diff --git a/src/w32-estream.c b/src/w32-estream.c
index 5bb1bcf..e17ea2c 100644
--- a/src/w32-estream.c
+++ b/src/w32-estream.c
@@ -1,1078 +1,1082 @@
/* w32-estream.c - es_poll support on W32.
* Copyright (C) 2000 Werner Koch (dd9jn)
* Copyright (C) 2001, 2002, 2003, 2004, 2007, 2010, 2016 g10 Code GmbH
*
* This file is part of libgpg-error.
*
* libgpg-error 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.
*
* libgpg-error 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 this program; if not, see .
*/
/*
* This file is based on GPGME's w32-io.c started in 2001.
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#ifdef HAVE_SYS_TIME_H
# include
#endif
#ifdef HAVE_SYS_TYPES_H
# include
#endif
#include
#include
+#ifndef EOPNOTSUPP
+# define EOPNOTSUPP ENOSYS
+#endif
+
/* Enable tracing. The value is the module name to be printed. */
/*#define ENABLE_TRACING "estream" */
#include "gpgrt-int.h"
/*
* In order to support es_poll on Windows, we create a proxy shim that
* we use as the estream I/O functions. This shim creates reader and
* writer threads that use the original I/O functions.
*/
/* Calculate array dimension. */
#ifndef DIM
#define DIM(array) (sizeof (array) / sizeof (*array))
#endif
#define READBUF_SIZE 8192
#define WRITEBUF_SIZE 8192
typedef struct estream_cookie_w32_pollable *estream_cookie_w32_pollable_t;
struct reader_context_s
{
estream_cookie_w32_pollable_t pcookie;
HANDLE thread_hd;
CRITICAL_SECTION mutex;
int stop_me;
int eof;
int eof_shortcut;
int error;
int error_code;
/* This is manually reset. */
HANDLE have_data_ev;
/* This is automatically reset. */
HANDLE have_space_ev;
/* This is manually reset but actually only triggered once. */
HANDLE close_ev;
size_t readpos, writepos;
char buffer[READBUF_SIZE];
};
struct writer_context_s
{
estream_cookie_w32_pollable_t pcookie;
HANDLE thread_hd;
CRITICAL_SECTION mutex;
int stop_me;
int error;
int error_code;
/* This is manually reset. */
HANDLE have_data;
HANDLE is_empty;
HANDLE close_ev;
size_t nbytes;
char buffer[WRITEBUF_SIZE];
};
/* Cookie for pollable objects. */
struct estream_cookie_w32_pollable
{
unsigned int modeflags;
struct cookie_io_functions_s next_functions;
void *next_cookie;
struct reader_context_s *reader;
struct writer_context_s *writer;
};
static DWORD CALLBACK
reader (void *arg)
{
struct reader_context_s *ctx = arg;
int nbytes;
ssize_t nread;
trace (("%p: reader starting", ctx));
for (;;)
{
EnterCriticalSection (&ctx->mutex);
/* Leave a 1 byte gap so that we can see whether it is empty or
full. */
while ((ctx->writepos + 1) % READBUF_SIZE == ctx->readpos)
{
/* Wait for space. */
if (!ResetEvent (ctx->have_space_ev))
trace (("%p: ResetEvent failed: ec=%d", ctx, (int)GetLastError()));
LeaveCriticalSection (&ctx->mutex);
trace (("%p: waiting for space", ctx));
WaitForSingleObject (ctx->have_space_ev, INFINITE);
trace (("%p: got space", ctx));
EnterCriticalSection (&ctx->mutex);
}
gpgrt_assert (((ctx->writepos + 1) % READBUF_SIZE != ctx->readpos));
if (ctx->stop_me)
{
LeaveCriticalSection (&ctx->mutex);
break;
}
nbytes = (ctx->readpos + READBUF_SIZE
- ctx->writepos - 1) % READBUF_SIZE;
gpgrt_assert (nbytes);
if (nbytes > READBUF_SIZE - ctx->writepos)
nbytes = READBUF_SIZE - ctx->writepos;
LeaveCriticalSection (&ctx->mutex);
trace (("%p: reading up to %d bytes", ctx, nbytes));
nread = ctx->pcookie->next_functions.public.func_read
(ctx->pcookie->next_cookie, ctx->buffer + ctx->writepos, nbytes);
trace (("%p: got %d bytes", ctx, nread));
if (nread < 0)
{
ctx->error_code = (int) errno;
/* NOTE (W32CE): Do not ignore ERROR_BUSY! Check at
least stop_me if that happens. */
if (ctx->error_code == ERROR_BROKEN_PIPE)
{
ctx->eof = 1;
trace (("%p: got EOF (broken pipe)", ctx));
}
else
{
ctx->error = 1;
trace (("%p: read error: ec=%d", ctx, ctx->error_code));
}
break;
}
EnterCriticalSection (&ctx->mutex);
if (ctx->stop_me)
{
LeaveCriticalSection (&ctx->mutex);
break;
}
if (!nread)
{
ctx->eof = 1;
trace (("%p: got eof", ctx));
LeaveCriticalSection (&ctx->mutex);
break;
}
ctx->writepos = (ctx->writepos + nread) % READBUF_SIZE;
if (!SetEvent (ctx->have_data_ev))
trace (("%p: SetEvent (%p) failed: ec=%d",
ctx, ctx->have_data_ev, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
}
/* Indicate that we have an error or EOF. */
if (!SetEvent (ctx->have_data_ev))
trace (("%p: SetEvent (%p) failed: ec=%d",
ctx, ctx->have_data_ev, (int)GetLastError ()));
trace (("%p: waiting for close", ctx));
WaitForSingleObject (ctx->close_ev, INFINITE);
CloseHandle (ctx->close_ev);
CloseHandle (ctx->have_data_ev);
CloseHandle (ctx->have_space_ev);
CloseHandle (ctx->thread_hd);
DeleteCriticalSection (&ctx->mutex);
free (ctx); /* Standard free! See comment in create_reader. */
return 0;
}
static struct reader_context_s *
create_reader (estream_cookie_w32_pollable_t pcookie)
{
struct reader_context_s *ctx;
SECURITY_ATTRIBUTES sec_attr;
DWORD tid;
memset (&sec_attr, 0, sizeof sec_attr);
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* The CTX must be allocated in standard system memory so that we
* won't use any custom allocation handler which may use our lock
* primitives for its implementation. The problem here is that the
* syscall clamp mechanism (e.g. nPth) would be called recursively:
* 1. For example by the caller of _gpgrt_w32_poll and 2. by
* gpgrt_lock_lock on behalf of the the custom allocation and free
* functions. */
ctx = calloc (1, sizeof *ctx);
if (!ctx)
{
return NULL;
}
ctx->pcookie = pcookie;
ctx->have_data_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (ctx->have_data_ev)
ctx->have_space_ev = CreateEvent (&sec_attr, FALSE, TRUE, NULL);
if (ctx->have_space_ev)
ctx->close_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (!ctx->have_data_ev || !ctx->have_space_ev || !ctx->close_ev)
{
trace (("%p: CreateEvent failed: ec=%d", ctx, (int)GetLastError ()));
if (ctx->have_data_ev)
CloseHandle (ctx->have_data_ev);
if (ctx->have_space_ev)
CloseHandle (ctx->have_space_ev);
if (ctx->close_ev)
CloseHandle (ctx->close_ev);
_gpgrt_free (ctx);
return NULL;
}
InitializeCriticalSection (&ctx->mutex);
#ifdef HAVE_W32CE_SYSTEM
ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, reader, ctx,
STACK_SIZE_PARAM_IS_A_RESERVATION, &tid);
#else
ctx->thread_hd = CreateThread (&sec_attr, 0, reader, ctx, 0, &tid);
#endif
if (!ctx->thread_hd)
{
trace (("%p: CreateThread failed: ec=%d", ctx, (int)GetLastError ()));
DeleteCriticalSection (&ctx->mutex);
if (ctx->have_data_ev)
CloseHandle (ctx->have_data_ev);
if (ctx->have_space_ev)
CloseHandle (ctx->have_space_ev);
if (ctx->close_ev)
CloseHandle (ctx->close_ev);
_gpgrt_free (ctx);
return NULL;
}
else
{
#if 0
/* We set the priority of the thread higher because we know that
it only runs for a short time. This greatly helps to
increase the performance of the I/O. */
SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());
#endif
}
return ctx;
}
/* Prepare destruction of the reader thread for CTX. Returns 0 if a
call to this function is sufficient and destroy_reader_finish shall
not be called. */
static void
destroy_reader (struct reader_context_s *ctx)
{
EnterCriticalSection (&ctx->mutex);
ctx->stop_me = 1;
if (ctx->have_space_ev)
SetEvent (ctx->have_space_ev);
LeaveCriticalSection (&ctx->mutex);
#ifdef HAVE_W32CE_SYSTEM
/* Scenario: We never create a full pipe, but already started
reading. Then we need to unblock the reader in the pipe driver
to make our reader thread notice that we want it to go away. */
if (ctx->file_hd != INVALID_HANDLE_VALUE)
{
if (!DeviceIoControl (ctx->file_hd, GPGCEDEV_IOCTL_UNBLOCK,
NULL, 0, NULL, 0, NULL, NULL))
{
trace (("%p: unblock control call failed: ec=%d",
ctx, (int)GetLastError ()));
}
}
#endif
/* XXX is it feasible to unblock the thread? */
/* After setting this event CTX is void. */
SetEvent (ctx->close_ev);
}
/*
* Read function for pollable objects.
*/
static gpgrt_ssize_t
func_w32_pollable_read (void *cookie, void *buffer, size_t count)
{
estream_cookie_w32_pollable_t pcookie = cookie;
gpgrt_ssize_t nread;
struct reader_context_s *ctx;
trace (("%p: enter buffer=%p count=%u", cookie, buffer, count));
/* FIXME: implement pending check if COUNT==0 */
ctx = pcookie->reader;
if (ctx == NULL)
{
pcookie->reader = ctx = create_reader (pcookie);
if (!ctx)
{
_gpg_err_set_errno (EBADF);
nread = -1;
goto leave;
}
trace (("%p: new reader %p", cookie, pcookie->reader));
}
if (ctx->eof_shortcut)
{
nread = 0;
goto leave;
}
EnterCriticalSection (&ctx->mutex);
trace (("%p: readpos: %d, writepos %d", cookie, ctx->readpos, ctx->writepos));
if (ctx->readpos == ctx->writepos && !ctx->error)
{
/* No data available. */
int eof = ctx->eof;
LeaveCriticalSection (&ctx->mutex);
if (pcookie->modeflags & O_NONBLOCK && ! eof)
{
_gpg_err_set_errno (EAGAIN);
nread = -1;
goto leave;
}
trace (("%p: waiting for data", cookie));
WaitForSingleObject (ctx->have_data_ev, INFINITE);
trace (("%p: data available", cookie));
EnterCriticalSection (&ctx->mutex);
}
if (ctx->readpos == ctx->writepos || ctx->error)
{
LeaveCriticalSection (&ctx->mutex);
ctx->eof_shortcut = 1;
if (ctx->eof)
return 0;
if (!ctx->error)
{
trace (("%p: EOF but ctx->eof flag not set", cookie));
nread = 0;
goto leave;
}
_gpg_err_set_errno (ctx->error_code);
return -1;
}
nread = ctx->readpos < ctx->writepos
? ctx->writepos - ctx->readpos
: READBUF_SIZE - ctx->readpos;
if (nread > count)
nread = count;
memcpy (buffer, ctx->buffer + ctx->readpos, nread);
ctx->readpos = (ctx->readpos + nread) % READBUF_SIZE;
if (ctx->readpos == ctx->writepos && !ctx->eof)
{
if (!ResetEvent (ctx->have_data_ev))
{
trace (("%p: ResetEvent failed: ec=%d",
cookie, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
nread = -1;
goto leave;
}
}
if (!SetEvent (ctx->have_space_ev))
{
trace (("%p: SetEvent (%p) failed: ec=%d",
cookie, ctx->have_space_ev, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
nread = -1;
goto leave;
}
LeaveCriticalSection (&ctx->mutex);
leave:
trace_errno (nread==-1,("%p: leave nread=%d", cookie, (int)nread));
return nread;
}
/* The writer does use a simple buffering strategy so that we are
informed about write errors as soon as possible (i. e. with the the
next call to the write function. */
static DWORD CALLBACK
writer (void *arg)
{
struct writer_context_s *ctx = arg;
ssize_t nwritten;
trace (("%p: writer starting", ctx));
for (;;)
{
EnterCriticalSection (&ctx->mutex);
if (ctx->stop_me && !ctx->nbytes)
{
LeaveCriticalSection (&ctx->mutex);
break;
}
if (!ctx->nbytes)
{
if (!SetEvent (ctx->is_empty))
trace (("%p: SetEvent failed: ec=%d", ctx, (int)GetLastError ()));
if (!ResetEvent (ctx->have_data))
trace (("%p: ResetEvent failed: ec=%d", ctx, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
trace (("%p: idle", ctx));
WaitForSingleObject (ctx->have_data, INFINITE);
trace (("%p: got data to write", ctx));
EnterCriticalSection (&ctx->mutex);
}
if (ctx->stop_me && !ctx->nbytes)
{
LeaveCriticalSection (&ctx->mutex);
break;
}
LeaveCriticalSection (&ctx->mutex);
trace (("%p: writing up to %d bytes", ctx, ctx->nbytes));
nwritten = ctx->pcookie->next_functions.public.func_write
(ctx->pcookie->next_cookie, ctx->buffer, ctx->nbytes);
trace (("%p: wrote %d bytes", ctx, nwritten));
if (nwritten < 1)
{
/* XXX */
if (errno == ERROR_BUSY)
{
/* Probably stop_me is set now. */
trace (("%p: pipe busy (unblocked?)", ctx));
continue;
}
ctx->error_code = errno;
ctx->error = 1;
trace (("%p: write error: ec=%d", ctx, ctx->error_code));
break;
}
EnterCriticalSection (&ctx->mutex);
ctx->nbytes -= nwritten;
LeaveCriticalSection (&ctx->mutex);
}
/* Indicate that we have an error. */
if (!SetEvent (ctx->is_empty))
trace (("%p: SetEvent failed: ec=%d", ctx, (int)GetLastError ()));
trace (("%p: waiting for close", ctx));
WaitForSingleObject (ctx->close_ev, INFINITE);
if (ctx->nbytes)
trace (("%p: still %d bytes in buffer at close time", ctx, ctx->nbytes));
CloseHandle (ctx->close_ev);
CloseHandle (ctx->have_data);
CloseHandle (ctx->is_empty);
CloseHandle (ctx->thread_hd);
DeleteCriticalSection (&ctx->mutex);
trace (("%p: writer is destroyed", ctx));
free (ctx); /* Standard free! See comment in create_writer. */
return 0;
}
static struct writer_context_s *
create_writer (estream_cookie_w32_pollable_t pcookie)
{
struct writer_context_s *ctx;
SECURITY_ATTRIBUTES sec_attr;
DWORD tid;
memset (&sec_attr, 0, sizeof sec_attr);
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* See comment at create_reader. */
ctx = calloc (1, sizeof *ctx);
if (!ctx)
{
return NULL;
}
ctx->pcookie = pcookie;
ctx->have_data = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (ctx->have_data)
ctx->is_empty = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
if (ctx->is_empty)
ctx->close_ev = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (!ctx->have_data || !ctx->is_empty || !ctx->close_ev)
{
trace (("%p: CreateEvent failed: ec=%d", ctx, (int)GetLastError ()));
if (ctx->have_data)
CloseHandle (ctx->have_data);
if (ctx->is_empty)
CloseHandle (ctx->is_empty);
if (ctx->close_ev)
CloseHandle (ctx->close_ev);
_gpgrt_free (ctx);
return NULL;
}
InitializeCriticalSection (&ctx->mutex);
#ifdef HAVE_W32CE_SYSTEM
ctx->thread_hd = CreateThread (&sec_attr, 64 * 1024, writer, ctx,
STACK_SIZE_PARAM_IS_A_RESERVATION, &tid);
#else
ctx->thread_hd = CreateThread (&sec_attr, 0, writer, ctx, 0, &tid );
#endif
if (!ctx->thread_hd)
{
trace (("%p: CreateThread failed: ec=%d", ctx, (int)GetLastError ()));
DeleteCriticalSection (&ctx->mutex);
if (ctx->have_data)
CloseHandle (ctx->have_data);
if (ctx->is_empty)
CloseHandle (ctx->is_empty);
if (ctx->close_ev)
CloseHandle (ctx->close_ev);
_gpgrt_free (ctx);
return NULL;
}
else
{
#if 0
/* We set the priority of the thread higher because we know
that it only runs for a short time. This greatly helps to
increase the performance of the I/O. */
SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());
#endif
}
return ctx;
}
static void
destroy_writer (struct writer_context_s *ctx)
{
trace (("%p: enter pollable_destroy_writer", ctx));
EnterCriticalSection (&ctx->mutex);
trace (("%p: setting stopme", ctx));
ctx->stop_me = 1;
if (ctx->have_data)
SetEvent (ctx->have_data);
LeaveCriticalSection (&ctx->mutex);
trace (("%p: waiting for empty", ctx));
/* Give the writer a chance to flush the buffer. */
WaitForSingleObject (ctx->is_empty, INFINITE);
#ifdef HAVE_W32CE_SYSTEM
/* Scenario: We never create a full pipe, but already started
writing more than the pipe buffer. Then we need to unblock the
writer in the pipe driver to make our writer thread notice that
we want it to go away. */
if (!DeviceIoControl (ctx->file_hd, GPGCEDEV_IOCTL_UNBLOCK,
NULL, 0, NULL, 0, NULL, NULL))
{
trace (("%p: unblock control call failed: ec=%d",
ctx, (int)GetLastError ()));
}
#endif
/* After setting this event CTX is void. */
trace (("%p: set close_ev", ctx));
SetEvent (ctx->close_ev);
trace (("%p: leave pollable_destroy_writer", ctx));
}
/*
* Write function for pollable objects.
*/
static gpgrt_ssize_t
func_w32_pollable_write (void *cookie, const void *buffer, size_t count)
{
estream_cookie_w32_pollable_t pcookie = cookie;
struct writer_context_s *ctx = pcookie->writer;
int nwritten;
trace (("%p: enter buffer: %p count: %d", cookie, buffer, count));
if (count == 0)
{
nwritten = 0;
goto leave;
}
if (ctx == NULL)
{
pcookie->writer = ctx = create_writer (pcookie);
if (!ctx)
{
nwritten = -1;
goto leave;
}
trace (("%p: new writer %p", cookie, pcookie->writer));
}
EnterCriticalSection (&ctx->mutex);
trace (("%p: buffer: %p, count: %d, nbytes: %d",
cookie, buffer, count, ctx->nbytes));
if (!ctx->error && ctx->nbytes)
{
/* Bytes are pending for send. */
/* Reset the is_empty event. Better safe than sorry. */
if (!ResetEvent (ctx->is_empty))
{
trace (("%p: ResetEvent failed: ec=%d",
cookie, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
nwritten = -1;
goto leave;
}
LeaveCriticalSection (&ctx->mutex);
if (pcookie->modeflags & O_NONBLOCK)
{
trace (("%p: would block", cookie));
_gpg_err_set_errno (EAGAIN);
nwritten = -1;
goto leave;
}
trace (("%p: waiting for empty buffer", cookie));
WaitForSingleObject (ctx->is_empty, INFINITE);
trace (("%p: buffer is empty", cookie));
EnterCriticalSection (&ctx->mutex);
}
if (ctx->error)
{
LeaveCriticalSection (&ctx->mutex);
if (ctx->error_code == ERROR_NO_DATA)
_gpg_err_set_errno (EPIPE);
else
_gpg_err_set_errno (EIO);
nwritten = -1;
goto leave;
}
/* If no error occurred, the number of bytes in the buffer must be
zero. */
gpgrt_assert (!ctx->nbytes);
if (count > WRITEBUF_SIZE)
count = WRITEBUF_SIZE;
memcpy (ctx->buffer, buffer, count);
ctx->nbytes = count;
/* We have to reset the is_empty event early, because it is also
used by the select() implementation to probe the channel. */
if (!ResetEvent (ctx->is_empty))
{
trace (("%p: ResetEvent failed: ec=%d", cookie, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
nwritten = -1;
goto leave;
}
if (!SetEvent (ctx->have_data))
{
trace (("%p: SetEvent failed: ec=%d", cookie, (int)GetLastError ()));
LeaveCriticalSection (&ctx->mutex);
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
nwritten = -1;
goto leave;
}
LeaveCriticalSection (&ctx->mutex);
nwritten = count;
leave:
trace_errno (nwritten==-1,("%p: leave nwritten=%d", cookie, nwritten));
return nwritten;
}
/* This is the core of _gpgrt_poll. The caller needs to make sure that
* the syscall clamp has been engaged. */
int
_gpgrt_w32_poll (gpgrt_poll_t *fds, size_t nfds, int timeout)
{
HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
int waitidx[MAXIMUM_WAIT_OBJECTS];
#ifdef ENABLE_TRACING
char waitinfo[MAXIMUM_WAIT_OBJECTS];
#endif
unsigned int code;
int nwait;
int i;
int any;
int count;
#if 0
restart:
#endif
any = 0;
nwait = 0;
count = 0;
for (i = 0; i < nfds; i++)
{
struct estream_cookie_w32_pollable *pcookie;
if (fds[i].ignore)
continue;
if (fds[i].stream->intern->kind != BACKEND_W32_POLLABLE)
{
/* This stream does not support polling. */
fds[i].got_err = 1;
continue;
}
pcookie = fds[i].stream->intern->cookie;
if (fds[i].want_read || fds[i].want_write)
{
/* XXX: What if one wants read and write, is that supported? */
if (fds[i].want_read)
{
struct reader_context_s *ctx = pcookie->reader;
if (ctx == NULL)
{
pcookie->reader = ctx = create_reader (pcookie);
if (!ctx)
{
/* FIXME: Is the error code appropriate? */
_gpg_err_set_errno (EBADF);
return -1;
}
trace (("%p: new reader %p", pcookie, pcookie->reader));
}
trace (("%p: using reader %p", pcookie, pcookie->reader));
if (nwait >= DIM (waitbuf))
{
trace (("oops: too many objects for WFMO"));
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
return -1;
}
waitidx[nwait] = i;
#ifdef ENABLE_TRACING
waitinfo[nwait] = 'r';
#endif /*ENABLE_TRACING*/
waitbuf[nwait++] = ctx->have_data_ev;
any = 1;
}
else if (fds[i].want_write)
{
struct writer_context_s *ctx = pcookie->writer;
if (ctx == NULL)
{
pcookie->writer = ctx = create_writer (pcookie);
if (!ctx)
{
trace (("oops: create writer failed"));
/* FIXME: Is the error code appropriate? */
_gpg_err_set_errno (EBADF);
return -1;
}
trace (("%p: new writer %p", pcookie, pcookie->writer));
}
trace (("%p: using writer %p", pcookie, pcookie->writer));
if (nwait >= DIM (waitbuf))
{
trace (("oops: Too many objects for WFMO"));
/* FIXME: Should translate the error code. */
_gpg_err_set_errno (EIO);
return -1;
}
waitidx[nwait] = i;
#ifdef ENABLE_TRACING
waitinfo[nwait] = 'w';
#endif /*ENABLE_TRACING*/
waitbuf[nwait++] = ctx->is_empty;
any = 1;
}
}
}
#ifdef ENABLE_TRACING
trace_start (("poll on [ "));
for (i = 0; i < nwait; i++)
trace_append (("%d/%c ", waitidx[i], waitinfo[i]));
trace_finish (("]"));
#endif /*ENABLE_TRACING*/
if (!any)
{
/* WFMO needs at least one object, thus we use use sleep here.
* INFINITE wait does not make any sense in this case, so we
* error out. */
if (timeout == -1)
{
_gpg_err_set_errno (EINVAL);
return -1;
}
if (timeout)
Sleep (timeout);
code = WAIT_TIMEOUT;
}
else
code = WaitForMultipleObjects (nwait, waitbuf, 0,
timeout == -1 ? INFINITE : timeout);
if (code < WAIT_OBJECT_0 + nwait)
{
/* This WFMO is a really silly function: It does return either
the index of the signaled object or if 2 objects have been
signalled at the same time, the index of the object with the
lowest object is returned - so and how do we find out how
many objects have been signaled???. The only solution I can
imagine is to test each object starting with the returned
index individually - how dull. */
any = 0;
for (i = code - WAIT_OBJECT_0; i < nwait; i++)
{
if (WaitForSingleObject (waitbuf[i], 0) == WAIT_OBJECT_0)
{
gpgrt_assert (waitidx[i] >=0 && waitidx[i] < nfds);
/* XXX: What if one wants read and write, is that
supported? */
if (fds[waitidx[i]].want_read)
fds[waitidx[i]].got_read = 1;
else if (fds[waitidx[i]].want_write)
fds[waitidx[i]].got_write = 1;
any = 1;
count++;
}
}
if (!any)
{
trace (("no signaled objects found after WFMO"));
count = -1;
}
}
else if (code == WAIT_TIMEOUT)
trace (("WFMO timed out"));
else if (code == WAIT_FAILED)
{
trace (("WFMO failed: ec=%d", (int)GetLastError ()));
#if 0
if (GetLastError () == ERROR_INVALID_HANDLE)
{
int k;
int j = handle_to_fd (waitbuf[i]);
trace (("WFMO invalid handle %d removed", j));
for (k = 0 ; k < nfds; k++)
{
if (fds[k].fd == j)
{
fds[k].want_read = fds[k].want_write = 0;
goto restart;
}
}
trace ((" oops, or not???"));
}
#endif
count = -1;
}
else
{
trace (("WFMO returned %u", code));
count = -1;
}
if (count > 0)
{
trace_start (("poll OK [ "));
for (i = 0; i < nfds; i++)
{
if (fds[i].ignore)
continue;
if (fds[i].got_read || fds[i].got_write)
trace_append (("%c%d ", fds[i].want_read ? 'r' : 'w', i));
}
trace_finish (("]"));
}
if (count < 0)
{
/* FIXME: Should determine a proper error code. */
_gpg_err_set_errno (EIO);
}
return count;
}
/*
* Implementation of pollable I/O on Windows.
*/
/*
* Constructor for pollable objects.
*/
int
_gpgrt_w32_pollable_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie,
unsigned int modeflags,
struct cookie_io_functions_s next_functions,
void *next_cookie)
{
estream_cookie_w32_pollable_t pcookie;
int err;
pcookie = _gpgrt_malloc (sizeof *pcookie);
if (!pcookie)
err = -1;
else
{
pcookie->modeflags = modeflags;
pcookie->next_functions = next_functions;
pcookie->next_cookie = next_cookie;
pcookie->reader = NULL;
pcookie->writer = NULL;
*cookie = pcookie;
err = 0;
}
trace_errno (err,("cookie=%p", *cookie));
return err;
}
/*
* Seek function for pollable objects.
*/
static int
func_w32_pollable_seek (void *cookie, gpgrt_off_t *offset, int whence)
{
estream_cookie_w32_pollable_t pcookie = cookie;
(void) pcookie;
(void) offset;
(void) whence;
/* XXX */
_gpg_err_set_errno (EOPNOTSUPP);
return -1;
}
/*
* The IOCTL function for pollable objects.
*/
static int
func_w32_pollable_ioctl (void *cookie, int cmd, void *ptr, size_t *len)
{
estream_cookie_w32_pollable_t pcookie = cookie;
cookie_ioctl_function_t func_ioctl = pcookie->next_functions.func_ioctl;
if (cmd == COOKIE_IOCTL_NONBLOCK)
{
if (ptr)
pcookie->modeflags |= O_NONBLOCK;
else
pcookie->modeflags &= ~O_NONBLOCK;
return 0;
}
if (func_ioctl)
return func_ioctl (pcookie->next_cookie, cmd, ptr, len);
_gpg_err_set_errno (EOPNOTSUPP);
return -1;
}
/*
* The destroy function for pollable objects.
*/
static int
func_w32_pollable_destroy (void *cookie)
{
estream_cookie_w32_pollable_t pcookie = cookie;
if (cookie)
{
if (pcookie->reader)
destroy_reader (pcookie->reader);
if (pcookie->writer)
destroy_writer (pcookie->writer);
pcookie->next_functions.public.func_close (pcookie->next_cookie);
_gpgrt_free (pcookie);
}
return 0;
}
/*
* Access object for the pollable functions.
*/
struct cookie_io_functions_s _gpgrt_functions_w32_pollable =
{
{
func_w32_pollable_read,
func_w32_pollable_write,
func_w32_pollable_seek,
func_w32_pollable_destroy,
},
func_w32_pollable_ioctl,
};