1 /*
   2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/log.hpp"
  27 #include "runtime/interfaceSupport.inline.hpp"
  28 #include "runtime/os.inline.hpp"
  29 #include "services/attachListener.hpp"
  30 #include "services/dtraceAttacher.hpp"
  31 
  32 #include <unistd.h>
  33 #include <signal.h>
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36 #include <sys/un.h>
  37 #include <sys/stat.h>
  38 
  39 #ifndef UNIX_PATH_MAX
  40 #define UNIX_PATH_MAX   sizeof(((struct sockaddr_un *)0)->sun_path)
  41 #endif
  42 
  43 // The attach mechanism on Bsd uses a UNIX domain socket. An attach listener
  44 // thread is created at startup or is created on-demand via a signal from
  45 // the client tool. The attach listener creates a socket and binds it to a file
  46 // in the filesystem. The attach listener then acts as a simple (single-
  47 // threaded) server - it waits for a client to connect, reads the request,
  48 // executes it, and returns the response to the client via the socket
  49 // connection.
  50 //
  51 // As the socket is a UNIX domain socket it means that only clients on the
  52 // local machine can connect. In addition there are two other aspects to
  53 // the security:
  54 // 1. The well known file that the socket is bound to has permission 400
  55 // 2. When a client connect, the SO_PEERCRED socket option is used to
  56 //    obtain the credentials of client. We check that the effective uid
  57 //    of the client matches this process.
  58 
  59 // forward reference
  60 class BsdAttachOperation;
  61 
  62 class BsdAttachListener: AllStatic {
  63  private:
  64   // the path to which we bind the UNIX domain socket
  65   static char _path[UNIX_PATH_MAX];
  66   static bool _has_path;
  67 
  68   // the file descriptor for the listening socket
  69   static int _listener;
  70 
  71   static void set_path(char* path) {
  72     if (path == NULL) {
  73       _has_path = false;
  74     } else {
  75       strncpy(_path, path, UNIX_PATH_MAX);
  76       _path[UNIX_PATH_MAX-1] = '\0';
  77       _has_path = true;
  78     }
  79   }
  80 
  81   static void set_listener(int s)               { _listener = s; }
  82 
  83   // reads a request from the given connected socket
  84   static BsdAttachOperation* read_request(int s);
  85 
  86  public:
  87   enum {
  88     ATTACH_PROTOCOL_VER = 1                     // protocol version
  89   };
  90   enum {
  91     ATTACH_ERROR_BADVERSION     = 101           // error codes
  92   };
  93 
  94   // initialize the listener, returns 0 if okay
  95   static int init();
  96 
  97   static char* path()                   { return _path; }
  98   static bool has_path()                { return _has_path; }
  99   static int listener()                 { return _listener; }
 100 
 101   // write the given buffer to a socket
 102   static int write_fully(int s, char* buf, int len);
 103 
 104   static BsdAttachOperation* dequeue();
 105 };
 106 
 107 class BsdAttachOperation: public AttachOperation {
 108  private:
 109   // the connection to the client
 110   int _socket;
 111 
 112  public:
 113   void complete(jint res, bufferedStream* st);
 114 
 115   void set_socket(int s)                                { _socket = s; }
 116   int socket() const                                    { return _socket; }
 117 
 118   BsdAttachOperation(char* name) : AttachOperation(name) {
 119     set_socket(-1);
 120   }
 121 };
 122 
 123 // statics
 124 char BsdAttachListener::_path[UNIX_PATH_MAX];
 125 bool BsdAttachListener::_has_path;
 126 int BsdAttachListener::_listener = -1;
 127 
 128 // Supporting class to help split a buffer into individual components
 129 class ArgumentIterator : public StackObj {
 130  private:
 131   char* _pos;
 132   char* _end;
 133  public:
 134   ArgumentIterator(char* arg_buffer, size_t arg_size) {
 135     _pos = arg_buffer;
 136     _end = _pos + arg_size - 1;
 137   }
 138   char* next() {
 139     if (*_pos == '\0') {
 140       return NULL;
 141     }
 142     char* res = _pos;
 143     char* next_pos = strchr(_pos, '\0');
 144     if (next_pos < _end)  {
 145       next_pos++;
 146     }
 147     _pos = next_pos;
 148     return res;
 149   }
 150 };
 151 
 152 
 153 // atexit hook to stop listener and unlink the file that it is
 154 // bound too.
 155 extern "C" {
 156   static void listener_cleanup() {
 157     static int cleanup_done;
 158     if (!cleanup_done) {
 159       cleanup_done = 1;
 160       int s = BsdAttachListener::listener();
 161       if (s != -1) {
 162         ::close(s);
 163       }
 164       if (BsdAttachListener::has_path()) {
 165         ::unlink(BsdAttachListener::path());
 166       }
 167     }
 168   }
 169 }
 170 
 171 // Initialization - create a listener socket and bind it to a file
 172 
 173 int BsdAttachListener::init() {
 174   char path[UNIX_PATH_MAX];          // socket file
 175   char initial_path[UNIX_PATH_MAX];  // socket file during setup
 176   int listener;                      // listener socket (file descriptor)
 177 
 178   // register function to cleanup
 179   ::atexit(listener_cleanup);
 180 
 181   int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d",
 182                    os::get_temp_directory(), os::current_process_id());
 183   if (n < (int)UNIX_PATH_MAX) {
 184     n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path);
 185   }
 186   if (n >= (int)UNIX_PATH_MAX) {
 187     return -1;
 188   }
 189 
 190   // create the listener socket
 191   listener = ::socket(PF_UNIX, SOCK_STREAM, 0);
 192   if (listener == -1) {
 193     return -1;
 194   }
 195 
 196   // bind socket
 197   struct sockaddr_un addr;
 198   addr.sun_family = AF_UNIX;
 199   strcpy(addr.sun_path, initial_path);
 200   ::unlink(initial_path);
 201   int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
 202   if (res == -1) {
 203     ::close(listener);
 204     return -1;
 205   }
 206 
 207   // put in listen mode, set permissions, and rename into place
 208   res = ::listen(listener, 5);
 209   if (res == 0) {
 210     RESTARTABLE(::chmod(initial_path, S_IREAD|S_IWRITE), res);
 211     if (res == 0) {
 212       // make sure the file is owned by the effective user and effective group
 213       // (this is the default on linux, but not on mac os)
 214       RESTARTABLE(::chown(initial_path, geteuid(), getegid()), res);
 215       if (res == 0) {
 216         res = ::rename(initial_path, path);
 217       }
 218     }
 219   }
 220   if (res == -1) {
 221     ::close(listener);
 222     ::unlink(initial_path);
 223     return -1;
 224   }
 225   set_path(path);
 226   set_listener(listener);
 227 
 228   return 0;
 229 }
 230 
 231 // Given a socket that is connected to a peer we read the request and
 232 // create an AttachOperation. As the socket is blocking there is potential
 233 // for a denial-of-service if the peer does not response. However this happens
 234 // after the peer credentials have been checked and in the worst case it just
 235 // means that the attach listener thread is blocked.
 236 //
 237 BsdAttachOperation* BsdAttachListener::read_request(int s) {
 238   char ver_str[8];
 239   sprintf(ver_str, "%d", ATTACH_PROTOCOL_VER);
 240 
 241   // The request is a sequence of strings so we first figure out the
 242   // expected count and the maximum possible length of the request.
 243   // The request is:
 244   //   <ver>0<cmd>0<arg>0<arg>0<arg>0
 245   // where <ver> is the protocol version (1), <cmd> is the command
 246   // name ("load", "datadump", ...), and <arg> is an argument
 247   int expected_str_count = 2 + AttachOperation::arg_count_max;
 248   const int max_len = (sizeof(ver_str) + 1) + (AttachOperation::name_length_max + 1) +
 249     AttachOperation::arg_count_max*(AttachOperation::arg_length_max + 1);
 250 
 251   char buf[max_len];
 252   int str_count = 0;
 253 
 254   // Read until all (expected) strings have been read, the buffer is
 255   // full, or EOF.
 256 
 257   int off = 0;
 258   int left = max_len;
 259 
 260   do {
 261     int n;
 262     RESTARTABLE(read(s, buf+off, left), n);
 263     if (n == -1) {
 264       return NULL;      // reset by peer or other error
 265     }
 266     if (n == 0) {
 267       break;
 268     }
 269     for (int i=0; i<n; i++) {
 270       if (buf[off+i] == 0) {
 271         // EOS found
 272         str_count++;
 273 
 274         // The first string is <ver> so check it now to
 275         // check for protocol mis-match
 276         if (str_count == 1) {
 277           if ((strlen(buf) != strlen(ver_str)) ||
 278               (atoi(buf) != ATTACH_PROTOCOL_VER)) {
 279             char msg[32];
 280             sprintf(msg, "%d\n", ATTACH_ERROR_BADVERSION);
 281             write_fully(s, msg, strlen(msg));
 282             return NULL;
 283           }
 284         }
 285       }
 286     }
 287     off += n;
 288     left -= n;
 289   } while (left > 0 && str_count < expected_str_count);
 290 
 291   if (str_count != expected_str_count) {
 292     return NULL;        // incomplete request
 293   }
 294 
 295   // parse request
 296 
 297   ArgumentIterator args(buf, (max_len)-left);
 298 
 299   // version already checked
 300   char* v = args.next();
 301 
 302   char* name = args.next();
 303   if (name == NULL || strlen(name) > AttachOperation::name_length_max) {
 304     return NULL;
 305   }
 306 
 307   BsdAttachOperation* op = new BsdAttachOperation(name);
 308 
 309   for (int i=0; i<AttachOperation::arg_count_max; i++) {
 310     char* arg = args.next();
 311     if (arg == NULL) {
 312       op->set_arg(i, NULL);
 313     } else {
 314       if (strlen(arg) > AttachOperation::arg_length_max) {
 315         delete op;
 316         return NULL;
 317       }
 318       op->set_arg(i, arg);
 319     }
 320   }
 321 
 322   op->set_socket(s);
 323   return op;
 324 }
 325 
 326 
 327 // Dequeue an operation
 328 //
 329 // In the Bsd implementation there is only a single operation and clients
 330 // cannot queue commands (except at the socket level).
 331 //
 332 BsdAttachOperation* BsdAttachListener::dequeue() {
 333   for (;;) {
 334     int s;
 335 
 336     // wait for client to connect
 337     struct sockaddr addr;
 338     socklen_t len = sizeof(addr);
 339     RESTARTABLE(::accept(listener(), &addr, &len), s);
 340     if (s == -1) {
 341       return NULL;      // log a warning?
 342     }
 343 
 344     // get the credentials of the peer and check the effective uid/guid
 345     // - check with jeff on this.
 346     uid_t puid;
 347     gid_t pgid;
 348     if (::getpeereid(s, &puid, &pgid) != 0) {
 349       ::close(s);
 350       continue;
 351     }
 352     uid_t euid = geteuid();
 353     gid_t egid = getegid();
 354 
 355     if (puid != euid || pgid != egid) {
 356       ::close(s);
 357       continue;
 358     }
 359 
 360     // peer credential look okay so we read the request
 361     BsdAttachOperation* op = read_request(s);
 362     if (op == NULL) {
 363       ::close(s);
 364       continue;
 365     } else {
 366       return op;
 367     }
 368   }
 369 }
 370 
 371 // write the given buffer to the socket
 372 int BsdAttachListener::write_fully(int s, char* buf, int len) {
 373   do {
 374     int n = ::write(s, buf, len);
 375     if (n == -1) {
 376       if (errno != EINTR) return -1;
 377     } else {
 378       buf += n;
 379       len -= n;
 380     }
 381   }
 382   while (len > 0);
 383   return 0;
 384 }
 385 
 386 // Complete an operation by sending the operation result and any result
 387 // output to the client. At this time the socket is in blocking mode so
 388 // potentially we can block if there is a lot of data and the client is
 389 // non-responsive. For most operations this is a non-issue because the
 390 // default send buffer is sufficient to buffer everything. In the future
 391 // if there are operations that involves a very big reply then it the
 392 // socket could be made non-blocking and a timeout could be used.
 393 
 394 void BsdAttachOperation::complete(jint result, bufferedStream* st) {
 395   JavaThread* thread = JavaThread::current();
 396   ThreadBlockInVM tbivm(thread);
 397 
 398   thread->set_suspend_equivalent();
 399   // cleared by handle_special_suspend_equivalent_condition() or
 400   // java_suspend_self() via check_and_wait_while_suspended()
 401 
 402   // write operation result
 403   char msg[32];
 404   sprintf(msg, "%d\n", result);
 405   int rc = BsdAttachListener::write_fully(this->socket(), msg, strlen(msg));
 406 
 407   // write any result data
 408   if (rc == 0) {
 409     BsdAttachListener::write_fully(this->socket(), (char*) st->base(), st->size());
 410     ::shutdown(this->socket(), 2);
 411   }
 412 
 413   // done
 414   ::close(this->socket());
 415 
 416   // were we externally suspended while we were waiting?
 417   thread->check_and_wait_while_suspended();
 418 
 419   delete this;
 420 }
 421 
 422 
 423 // AttachListener functions
 424 
 425 AttachOperation* AttachListener::dequeue() {
 426   JavaThread* thread = JavaThread::current();
 427   ThreadBlockInVM tbivm(thread);
 428 
 429   thread->set_suspend_equivalent();
 430   // cleared by handle_special_suspend_equivalent_condition() or
 431   // java_suspend_self() via check_and_wait_while_suspended()
 432 
 433   AttachOperation* op = BsdAttachListener::dequeue();
 434 
 435   // were we externally suspended while we were waiting?
 436   thread->check_and_wait_while_suspended();
 437 
 438   return op;
 439 }
 440 
 441 
 442 // Performs initialization at vm startup
 443 // For BSD we remove any stale .java_pid file which could cause
 444 // an attaching process to think we are ready to receive on the
 445 // domain socket before we are properly initialized
 446 
 447 void AttachListener::vm_start() {
 448   char fn[UNIX_PATH_MAX];
 449   struct stat st;
 450   int ret;
 451 
 452   int n = snprintf(fn, UNIX_PATH_MAX, "%s/.java_pid%d",
 453            os::get_temp_directory(), os::current_process_id());
 454   assert(n < (int)UNIX_PATH_MAX, "java_pid file name buffer overflow");
 455 
 456   RESTARTABLE(::stat(fn, &st), ret);
 457   if (ret == 0) {
 458     ret = ::unlink(fn);
 459     if (ret == -1) {
 460       log_debug(attach)("Failed to remove stale attach pid file at %s", fn);
 461     }
 462   }
 463 }
 464 
 465 int AttachListener::pd_init() {
 466   JavaThread* thread = JavaThread::current();
 467   ThreadBlockInVM tbivm(thread);
 468 
 469   thread->set_suspend_equivalent();
 470   // cleared by handle_special_suspend_equivalent_condition() or
 471   // java_suspend_self() via check_and_wait_while_suspended()
 472 
 473   int ret_code = BsdAttachListener::init();
 474 
 475   // were we externally suspended while we were waiting?
 476   thread->check_and_wait_while_suspended();
 477 
 478   return ret_code;
 479 }
 480 
 481 // Attach Listener is started lazily except in the case when
 482 // +ReduseSignalUsage is used
 483 bool AttachListener::init_at_startup() {
 484   if (ReduceSignalUsage) {
 485     return true;
 486   } else {
 487     return false;
 488   }
 489 }
 490 
 491 // If the file .attach_pid<pid> exists in the working directory
 492 // or /tmp then this is the trigger to start the attach mechanism
 493 bool AttachListener::is_init_trigger() {
 494   if (init_at_startup() || is_initialized()) {
 495     return false;               // initialized at startup or already initialized
 496   }
 497   char fn[PATH_MAX + 1];
 498   int ret;
 499   struct stat st;
 500 
 501   snprintf(fn, PATH_MAX + 1, "%s/.attach_pid%d",
 502            os::get_temp_directory(), os::current_process_id());
 503   RESTARTABLE(::stat(fn, &st), ret);
 504   if (ret == -1) {
 505     log_debug(attach)("Failed to find attach file: %s", fn);
 506   }
 507   if (ret == 0) {
 508     // simple check to avoid starting the attach mechanism when
 509     // a bogus user creates the file
 510     if (st.st_uid == geteuid()) {
 511       init();
 512       log_trace(attach)("Attach trigerred by %s", fn);
 513       return true;
 514     } else {
 515       log_debug(attach)("File %s has wrong user id %d (vs %d). Attach is not triggered", fn, st.st_uid, geteuid());
 516     }
 517   }
 518   return false;
 519 }
 520 
 521 // if VM aborts then remove listener
 522 void AttachListener::abort() {
 523   listener_cleanup();
 524 }
 525 
 526 void AttachListener::pd_data_dump() {
 527   os::signal_notify(SIGQUIT);
 528 }
 529 
 530 AttachOperationFunctionInfo* AttachListener::pd_find_operation(const char* n) {
 531   return NULL;
 532 }
 533 
 534 jint AttachListener::pd_set_flag(AttachOperation* op, outputStream* out) {
 535   out->print_cr("flag '%s' cannot be changed", op->arg(0));
 536   return JNI_ERR;
 537 }
 538 
 539 void AttachListener::pd_detachall() {
 540   // do nothing for now
 541 }