blob: 8603a886a099d06cc4a08202d3a56395d1aadedf [file] [log] [blame]
/* C++ modules. Experimental!
Copyright (C) 2017-2022 Free Software Foundation, Inc.
Written by Nathan Sidwell <nathan@acm.org> while at FaceBook
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#if defined (__unix__)
// Solaris11's socket header used bcopy, which we poison. cody.hh
// will include it later under the above check
#include <sys/socket.h>
#endif
#define INCLUDE_STRING
#define INCLUDE_VECTOR
#define INCLUDE_MAP
#include "system.h"
#include "line-map.h"
#include "diagnostic-core.h"
#include "mapper-client.h"
#include "intl.h"
#include "../../c++tools/resolver.h"
#if !HOST_HAS_O_CLOEXEC
#define O_CLOEXEC 0
#endif
module_client::module_client (pex_obj *p, int fd_from, int fd_to)
: Client (fd_from, fd_to), pex (p)
{
}
static module_client *
spawn_mapper_program (char const **errmsg, std::string &name,
char const *full_program_name)
{
/* Split writable at white-space. No space-containing args for
you! */
// At most every other char could be an argument
char **argv = new char *[name.size () / 2 + 2];
unsigned arg_no = 0;
char *str = new char[name.size ()];
memcpy (str, name.c_str () + 1, name.size ());
for (auto ptr = str; ; ++ptr)
{
while (*ptr == ' ')
ptr++;
if (!*ptr)
break;
if (!arg_no)
{
/* @name means look in the compiler's install dir. */
if (ptr[0] == '@')
ptr++;
else
full_program_name = nullptr;
}
argv[arg_no++] = ptr;
while (*ptr && *ptr != ' ')
ptr++;
if (!*ptr)
break;
*ptr = 0;
}
argv[arg_no] = nullptr;
auto *pex = pex_init (PEX_USE_PIPES, progname, NULL);
FILE *to = pex_input_pipe (pex, false);
name = argv[0];
if (!to)
*errmsg = "connecting input";
else
{
int flags = PEX_SEARCH;
if (full_program_name)
{
/* Prepend the invoking path, if the mapper is a simple
file name. */
size_t dir_len = progname - full_program_name;
std::string argv0;
argv0.reserve (dir_len + name.size ());
argv0.append (full_program_name, dir_len).append (name);
name = std::move (argv0);
argv[0] = const_cast <char *> (name.c_str ());
flags = 0;
}
int err;
*errmsg = pex_run (pex, flags, argv[0], argv, NULL, NULL, &err);
}
delete[] str;
delete[] argv;
int fd_from = -1, fd_to = -1;
if (!*errmsg)
{
FILE *from = pex_read_output (pex, false);
if (from && (fd_to = dup (fileno (to))) >= 0)
fd_from = fileno (from);
else
*errmsg = "connecting output";
fclose (to);
}
if (*errmsg)
{
pex_free (pex);
return nullptr;
}
return new module_client (pex, fd_from, fd_to);
}
module_client *
module_client::open_module_client (location_t loc, const char *o,
void (*set_repo) (const char *),
char const *full_program_name)
{
module_client *c = nullptr;
std::string ident;
std::string name;
char const *errmsg = nullptr;
unsigned line = 0;
if (o && o[0])
{
/* Maybe a local or ipv6 address. */
name = o;
auto last = name.find_last_of ('?');
if (last != name.npos)
{
ident = name.substr (last + 1);
name.erase (last);
}
if (name.size ())
{
switch (name[0])
{
case '<':
// <from>to or <>fromto, or <>
{
size_t pos = name.find ('>', 1);
if (pos == std::string::npos)
pos = name.size ();
std::string from (name, 1, pos - 1);
std::string to;
if (pos != name.size ())
to.append (name, pos + 1, std::string::npos);
int fd_from = -1, fd_to = -1;
if (from.empty () && to.empty ())
{
fd_from = fileno (stdin);
fd_to = fileno (stdout);
}
else
{
char *ptr;
if (!from.empty ())
{
/* Sadly str::stoul is not portable. */
const char *cstr = from.c_str ();
fd_from = strtoul (cstr, &ptr, 10);
if (*ptr)
{
/* Not a number -- a named pipe. */
int dir = to.empty ()
? O_RDWR | O_CLOEXEC : O_RDONLY | O_CLOEXEC;
fd_from = open (cstr, dir);
}
if (to.empty ())
fd_to = fd_from;
}
if (!from.empty () && fd_from < 0)
;
else if (to.empty ())
;
else
{
const char *cstr = to.c_str ();
fd_to = strtoul (cstr, &ptr, 10);
if (*ptr)
{
/* Not a number, a named pipe. */
int dir = from.empty ()
? O_RDWR | O_CLOEXEC : O_WRONLY | O_CLOEXEC;
fd_to = open (cstr, dir);
if (fd_to < 0)
close (fd_from);
}
if (from.empty ())
fd_from = fd_to;
}
}
if (fd_from < 0 || fd_to < 0)
errmsg = "opening";
else
c = new module_client (fd_from, fd_to);
}
break;
case '=':
// =localsocket
{
int fd = -1;
#if CODY_NETWORKING
fd = Cody::OpenLocal (&errmsg, name.c_str () + 1);
#endif
if (fd >= 0)
c = new module_client (fd, fd);
}
break;
case '|':
// |program and args
c = spawn_mapper_program (&errmsg, name, full_program_name);
break;
default:
// file or hostname:port
{
auto colon = name.find_last_of (':');
if (colon != name.npos)
{
char const *cptr = name.c_str () + colon;
char *endp;
unsigned port = strtoul (cptr + 1, &endp, 10);
if (port && endp != cptr + 1 && !*endp)
{
name[colon] = 0;
int fd = -1;
#if CODY_NETWORKING
fd = Cody::OpenInet6 (&errmsg, name.c_str (), port);
#endif
name[colon] = ':';
if (fd >= 0)
c = new module_client (fd, fd);
}
}
}
break;
}
}
}
if (!c)
{
// Make a default in-process client
bool file = !errmsg && !name.empty ();
auto r = new module_resolver (!file, true);
if (file)
{
int fd = open (name.c_str (), O_RDONLY | O_CLOEXEC);
if (fd < 0)
errmsg = "opening";
else
{
if (int l = r->read_tuple_file (fd, ident, false))
{
if (l > 0)
line = l;
errmsg = "reading";
}
close (fd);
}
}
else
r->set_repo ("gcm.cache");
auto *s = new Cody::Server (r);
c = new module_client (s);
}
#ifdef SIGPIPE
if (!c->IsDirect ())
/* We need to ignore sig pipe for a while. */
c->sigpipe = signal (SIGPIPE, SIG_IGN);
#endif
if (errmsg)
error_at (loc, line ? G_("failed %s mapper %qs line %u")
: G_("failed %s mapper %qs"), errmsg, name.c_str (), line);
// now wave hello!
c->Cork ();
c->Connect (std::string ("GCC"), ident);
c->ModuleRepo ();
auto packets = c->Uncork ();
auto &connect = packets[0];
if (connect.GetCode () == Cody::Client::PC_CONNECT)
c->flags = Cody::Flags (connect.GetInteger ());
else if (connect.GetCode () == Cody::Client::PC_ERROR)
error_at (loc, "failed mapper handshake %s", connect.GetString ().c_str ());
auto &repo = packets[1];
if (repo.GetCode () == Cody::Client::PC_PATHNAME)
set_repo (repo.GetString ().c_str ());
return c;
}
void
module_client::close_module_client (location_t loc, module_client *mapper)
{
if (mapper->IsDirect ())
{
auto *s = mapper->GetServer ();
auto *r = s->GetResolver ();
delete s;
delete r;
}
else
{
if (mapper->pex)
{
int fd_write = mapper->GetFDWrite ();
if (fd_write >= 0)
close (fd_write);
int status;
pex_get_status (mapper->pex, 1, &status);
pex_free (mapper->pex);
mapper->pex = NULL;
if (WIFSIGNALED (status))
error_at (loc, "mapper died by signal %s",
strsignal (WTERMSIG (status)));
else if (WIFEXITED (status) && WEXITSTATUS (status) != 0)
error_at (loc, "mapper exit status %d",
WEXITSTATUS (status));
}
else
{
int fd_read = mapper->GetFDRead ();
close (fd_read);
}
#ifdef SIGPIPE
// Restore sigpipe
if (mapper->sigpipe != SIG_IGN)
signal (SIGPIPE, mapper->sigpipe);
#endif
}
delete mapper;
}