| /* 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; |
| } |