744 lines
20 KiB
C++
744 lines
20 KiB
C++
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/* implement the "debug-ports" and "track-debug-ports" device services */
|
|
|
|
#define TRACE_TAG JDWP
|
|
|
|
#include "sysdeps.h"
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "adb.h"
|
|
#include "adb_utils.h"
|
|
|
|
/* here's how these things work.
|
|
|
|
when adbd starts, it creates a unix server socket
|
|
named @vm-debug-control (@ is a shortcut for "first byte is zero"
|
|
to use the private namespace instead of the file system)
|
|
|
|
when a new JDWP daemon thread starts in a new VM process, it creates
|
|
a connection to @vm-debug-control to announce its availability.
|
|
|
|
|
|
JDWP thread @vm-debug-control
|
|
| |
|
|
|-------------------------------> |
|
|
| hello I'm in process <pid> |
|
|
| |
|
|
| |
|
|
|
|
the connection is kept alive. it will be closed automatically if
|
|
the JDWP process terminates (this allows adbd to detect dead
|
|
processes).
|
|
|
|
adbd thus maintains a list of "active" JDWP processes. it can send
|
|
its content to clients through the "device:debug-ports" service,
|
|
or even updates through the "device:track-debug-ports" service.
|
|
|
|
when a debugger wants to connect, it simply runs the command
|
|
equivalent to "adb forward tcp:<hostport> jdwp:<pid>"
|
|
|
|
"jdwp:<pid>" is a new forward destination format used to target
|
|
a given JDWP process on the device. when sutch a request arrives,
|
|
adbd does the following:
|
|
|
|
- first, it calls socketpair() to create a pair of equivalent
|
|
sockets.
|
|
|
|
- it attaches the first socket in the pair to a local socket
|
|
which is itself attached to the transport's remote socket:
|
|
|
|
|
|
- it sends the file descriptor of the second socket directly
|
|
to the JDWP process with the help of sendmsg()
|
|
|
|
|
|
JDWP thread @vm-debug-control
|
|
| |
|
|
| <----------------------|
|
|
| OK, try this file descriptor |
|
|
| |
|
|
| |
|
|
|
|
then, the JDWP thread uses this new socket descriptor as its
|
|
pass-through connection to the debugger (and receives the
|
|
JDWP-Handshake message, answers to it, etc...)
|
|
|
|
this gives the following graphics:
|
|
____________________________________
|
|
| |
|
|
| ADB Server (host) |
|
|
| |
|
|
Debugger <---> LocalSocket <----> RemoteSocket |
|
|
| ^^ |
|
|
|___________________________||_______|
|
|
||
|
|
Transport ||
|
|
(TCP for emulator - USB for device) ||
|
|
||
|
|
___________________________||_______
|
|
| || |
|
|
| ADBD (device) || |
|
|
| VV |
|
|
JDWP <======> LocalSocket <----> RemoteSocket |
|
|
| |
|
|
|____________________________________|
|
|
|
|
due to the way adb works, this doesn't need a special socket
|
|
type or fancy handling of socket termination if either the debugger
|
|
or the JDWP process closes the connection.
|
|
|
|
THIS IS THE SIMPLEST IMPLEMENTATION I COULD FIND, IF YOU HAPPEN
|
|
TO HAVE A BETTER IDEA, LET ME KNOW - Digit
|
|
|
|
**********************************************************************/
|
|
|
|
/** JDWP PID List Support Code
|
|
** for each JDWP process, we record its pid and its connected socket
|
|
**/
|
|
|
|
#define MAX_OUT_FDS 4
|
|
|
|
#if !ADB_HOST
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
|
|
struct JdwpProcess {
|
|
JdwpProcess* next;
|
|
JdwpProcess* prev;
|
|
int pid;
|
|
int socket;
|
|
fdevent* fde;
|
|
|
|
char in_buff[4]; /* input character to read PID */
|
|
int in_len; /* number from JDWP process */
|
|
|
|
int out_fds[MAX_OUT_FDS]; /* output array of file descriptors */
|
|
int out_count; /* to send to the JDWP process */
|
|
};
|
|
|
|
static JdwpProcess _jdwp_list;
|
|
|
|
static int
|
|
jdwp_process_list( char* buffer, int bufferlen )
|
|
{
|
|
char* end = buffer + bufferlen;
|
|
char* p = buffer;
|
|
JdwpProcess* proc = _jdwp_list.next;
|
|
|
|
for ( ; proc != &_jdwp_list; proc = proc->next ) {
|
|
int len;
|
|
|
|
/* skip transient connections */
|
|
if (proc->pid < 0)
|
|
continue;
|
|
|
|
len = snprintf(p, end-p, "%d\n", proc->pid);
|
|
if (p + len >= end)
|
|
break;
|
|
p += len;
|
|
}
|
|
p[0] = 0;
|
|
return (p - buffer);
|
|
}
|
|
|
|
|
|
static int
|
|
jdwp_process_list_msg( char* buffer, int bufferlen )
|
|
{
|
|
char head[5];
|
|
int len = jdwp_process_list( buffer+4, bufferlen-4 );
|
|
snprintf(head, sizeof head, "%04x", len);
|
|
memcpy(buffer, head, 4);
|
|
return len + 4;
|
|
}
|
|
|
|
|
|
static void jdwp_process_list_updated(void);
|
|
|
|
static void
|
|
jdwp_process_free( JdwpProcess* proc )
|
|
{
|
|
if (proc) {
|
|
int n;
|
|
|
|
proc->prev->next = proc->next;
|
|
proc->next->prev = proc->prev;
|
|
|
|
if (proc->socket >= 0) {
|
|
adb_shutdown(proc->socket);
|
|
adb_close(proc->socket);
|
|
proc->socket = -1;
|
|
}
|
|
|
|
if (proc->fde != NULL) {
|
|
fdevent_destroy(proc->fde);
|
|
proc->fde = NULL;
|
|
}
|
|
proc->pid = -1;
|
|
|
|
for (n = 0; n < proc->out_count; n++) {
|
|
adb_close(proc->out_fds[n]);
|
|
}
|
|
proc->out_count = 0;
|
|
|
|
free(proc);
|
|
|
|
jdwp_process_list_updated();
|
|
}
|
|
}
|
|
|
|
|
|
static void jdwp_process_event(int, unsigned, void*); /* forward */
|
|
|
|
|
|
static JdwpProcess*
|
|
jdwp_process_alloc( int socket )
|
|
{
|
|
JdwpProcess* proc = reinterpret_cast<JdwpProcess*>(
|
|
calloc(1, sizeof(*proc)));
|
|
|
|
if (proc == NULL) {
|
|
D("not enough memory to create new JDWP process");
|
|
return NULL;
|
|
}
|
|
|
|
proc->socket = socket;
|
|
proc->pid = -1;
|
|
proc->next = proc;
|
|
proc->prev = proc;
|
|
|
|
proc->fde = fdevent_create( socket, jdwp_process_event, proc );
|
|
if (proc->fde == NULL) {
|
|
D("could not create fdevent for new JDWP process" );
|
|
free(proc);
|
|
return NULL;
|
|
}
|
|
|
|
proc->fde->state |= FDE_DONT_CLOSE;
|
|
proc->in_len = 0;
|
|
proc->out_count = 0;
|
|
|
|
/* append to list */
|
|
proc->next = &_jdwp_list;
|
|
proc->prev = proc->next->prev;
|
|
|
|
proc->prev->next = proc;
|
|
proc->next->prev = proc;
|
|
|
|
/* start by waiting for the PID */
|
|
fdevent_add(proc->fde, FDE_READ);
|
|
|
|
return proc;
|
|
}
|
|
|
|
|
|
static void
|
|
jdwp_process_event( int socket, unsigned events, void* _proc )
|
|
{
|
|
JdwpProcess* proc = reinterpret_cast<JdwpProcess*>(_proc);
|
|
|
|
if (events & FDE_READ) {
|
|
if (proc->pid < 0) {
|
|
/* read the PID as a 4-hexchar string */
|
|
char* p = proc->in_buff + proc->in_len;
|
|
int size = 4 - proc->in_len;
|
|
char temp[5];
|
|
while (size > 0) {
|
|
int len = recv( socket, p, size, 0 );
|
|
if (len < 0) {
|
|
if (errno == EINTR)
|
|
continue;
|
|
if (errno == EAGAIN)
|
|
return;
|
|
/* this can fail here if the JDWP process crashes very fast */
|
|
D("weird unknown JDWP process failure: %s",
|
|
strerror(errno));
|
|
|
|
goto CloseProcess;
|
|
}
|
|
if (len == 0) { /* end of stream ? */
|
|
D("weird end-of-stream from unknown JDWP process");
|
|
goto CloseProcess;
|
|
}
|
|
p += len;
|
|
proc->in_len += len;
|
|
size -= len;
|
|
}
|
|
/* we have read 4 characters, now decode the pid */
|
|
memcpy(temp, proc->in_buff, 4);
|
|
temp[4] = 0;
|
|
|
|
if (sscanf( temp, "%04x", &proc->pid ) != 1) {
|
|
D("could not decode JDWP %p PID number: '%s'", proc, temp);
|
|
goto CloseProcess;
|
|
}
|
|
|
|
/* all is well, keep reading to detect connection closure */
|
|
D("Adding pid %d to jdwp process list", proc->pid);
|
|
jdwp_process_list_updated();
|
|
}
|
|
else
|
|
{
|
|
/* the pid was read, if we get there it's probably because the connection
|
|
* was closed (e.g. the JDWP process exited or crashed) */
|
|
char buf[32];
|
|
|
|
for (;;) {
|
|
int len = recv(socket, buf, sizeof(buf), 0);
|
|
|
|
if (len <= 0) {
|
|
if (len < 0 && errno == EINTR)
|
|
continue;
|
|
if (len < 0 && errno == EAGAIN)
|
|
return;
|
|
else {
|
|
D("terminating JDWP %d connection: %s", proc->pid,
|
|
strerror(errno));
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
D( "ignoring unexpected JDWP %d control socket activity (%d bytes)",
|
|
proc->pid, len );
|
|
}
|
|
}
|
|
|
|
CloseProcess:
|
|
if (proc->pid >= 0) {
|
|
D( "remove pid %d to jdwp process list", proc->pid );
|
|
}
|
|
jdwp_process_free(proc);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (events & FDE_WRITE) {
|
|
D("trying to write to JDWP pid controli (count=%d first=%d) %d",
|
|
proc->pid, proc->out_count, proc->out_fds[0]);
|
|
if (proc->out_count > 0) {
|
|
int fd = proc->out_fds[0];
|
|
int n, ret;
|
|
struct cmsghdr* cmsg;
|
|
struct msghdr msg;
|
|
struct iovec iov;
|
|
char dummy = '!';
|
|
char buffer[sizeof(struct cmsghdr) + sizeof(int)];
|
|
|
|
iov.iov_base = &dummy;
|
|
iov.iov_len = 1;
|
|
msg.msg_name = NULL;
|
|
msg.msg_namelen = 0;
|
|
msg.msg_iov = &iov;
|
|
msg.msg_iovlen = 1;
|
|
msg.msg_flags = 0;
|
|
msg.msg_control = buffer;
|
|
msg.msg_controllen = sizeof(buffer);
|
|
|
|
cmsg = CMSG_FIRSTHDR(&msg);
|
|
cmsg->cmsg_len = msg.msg_controllen;
|
|
cmsg->cmsg_level = SOL_SOCKET;
|
|
cmsg->cmsg_type = SCM_RIGHTS;
|
|
((int*)CMSG_DATA(cmsg))[0] = fd;
|
|
|
|
if (!set_file_block_mode(proc->socket, true)) {
|
|
VLOG(JDWP) << "failed to set blocking mode for fd " << proc->socket;
|
|
goto CloseProcess;
|
|
}
|
|
|
|
for (;;) {
|
|
ret = sendmsg(proc->socket, &msg, 0);
|
|
if (ret >= 0) {
|
|
adb_close(fd);
|
|
break;
|
|
}
|
|
if (errno == EINTR)
|
|
continue;
|
|
D("sending new file descriptor to JDWP %d failed: %s",
|
|
proc->pid, strerror(errno));
|
|
goto CloseProcess;
|
|
}
|
|
|
|
D("sent file descriptor %d to JDWP process %d",
|
|
fd, proc->pid);
|
|
|
|
for (n = 1; n < proc->out_count; n++)
|
|
proc->out_fds[n-1] = proc->out_fds[n];
|
|
|
|
if (!set_file_block_mode(proc->socket, false)) {
|
|
VLOG(JDWP) << "failed to set non-blocking mode for fd " << proc->socket;
|
|
goto CloseProcess;
|
|
}
|
|
|
|
if (--proc->out_count == 0)
|
|
fdevent_del( proc->fde, FDE_WRITE );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
create_jdwp_connection_fd(int pid)
|
|
{
|
|
JdwpProcess* proc = _jdwp_list.next;
|
|
|
|
D("looking for pid %d in JDWP process list", pid);
|
|
for ( ; proc != &_jdwp_list; proc = proc->next ) {
|
|
if (proc->pid == pid) {
|
|
goto FoundIt;
|
|
}
|
|
}
|
|
D("search failed !!");
|
|
return -1;
|
|
|
|
FoundIt:
|
|
{
|
|
int fds[2];
|
|
|
|
if (proc->out_count >= MAX_OUT_FDS) {
|
|
D("%s: too many pending JDWP connection for pid %d",
|
|
__FUNCTION__, pid);
|
|
return -1;
|
|
}
|
|
|
|
if (adb_socketpair(fds) < 0) {
|
|
D("%s: socket pair creation failed: %s",
|
|
__FUNCTION__, strerror(errno));
|
|
return -1;
|
|
}
|
|
D("socketpair: (%d,%d)", fds[0], fds[1]);
|
|
|
|
proc->out_fds[ proc->out_count ] = fds[1];
|
|
if (++proc->out_count == 1)
|
|
fdevent_add( proc->fde, FDE_WRITE );
|
|
|
|
return fds[0];
|
|
}
|
|
}
|
|
|
|
/** VM DEBUG CONTROL SOCKET
|
|
**
|
|
** we do implement a custom asocket to receive the data
|
|
**/
|
|
|
|
/* name of the debug control Unix socket */
|
|
#define JDWP_CONTROL_NAME "\0jdwp-control"
|
|
#define JDWP_CONTROL_NAME_LEN (sizeof(JDWP_CONTROL_NAME)-1)
|
|
|
|
struct JdwpControl {
|
|
int listen_socket;
|
|
fdevent* fde;
|
|
};
|
|
|
|
|
|
static void
|
|
jdwp_control_event(int s, unsigned events, void* user);
|
|
|
|
|
|
static int
|
|
jdwp_control_init( JdwpControl* control,
|
|
const char* sockname,
|
|
int socknamelen )
|
|
{
|
|
struct sockaddr_un addr;
|
|
socklen_t addrlen;
|
|
int s;
|
|
int maxpath = sizeof(addr.sun_path);
|
|
int pathlen = socknamelen;
|
|
|
|
if (pathlen >= maxpath) {
|
|
D( "vm debug control socket name too long (%d extra chars)",
|
|
pathlen+1-maxpath );
|
|
return -1;
|
|
}
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sun_family = AF_UNIX;
|
|
memcpy(addr.sun_path, sockname, socknamelen);
|
|
|
|
s = socket( AF_UNIX, SOCK_STREAM, 0 );
|
|
if (s < 0) {
|
|
D( "could not create vm debug control socket. %d: %s",
|
|
errno, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
addrlen = (pathlen + sizeof(addr.sun_family));
|
|
|
|
if (bind(s, (struct sockaddr*)&addr, addrlen) < 0) {
|
|
D( "could not bind vm debug control socket: %d: %s",
|
|
errno, strerror(errno) );
|
|
adb_close(s);
|
|
return -1;
|
|
}
|
|
|
|
if ( listen(s, 4) < 0 ) {
|
|
D("listen failed in jdwp control socket: %d: %s",
|
|
errno, strerror(errno));
|
|
adb_close(s);
|
|
return -1;
|
|
}
|
|
|
|
control->listen_socket = s;
|
|
|
|
control->fde = fdevent_create(s, jdwp_control_event, control);
|
|
if (control->fde == NULL) {
|
|
D( "could not create fdevent for jdwp control socket" );
|
|
adb_close(s);
|
|
return -1;
|
|
}
|
|
|
|
/* only wait for incoming connections */
|
|
fdevent_add(control->fde, FDE_READ);
|
|
close_on_exec(s);
|
|
|
|
D("jdwp control socket started (%d)", control->listen_socket);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
jdwp_control_event( int s, unsigned events, void* _control )
|
|
{
|
|
JdwpControl* control = (JdwpControl*) _control;
|
|
|
|
if (events & FDE_READ) {
|
|
struct sockaddr addr;
|
|
socklen_t addrlen = sizeof(addr);
|
|
int s = -1;
|
|
JdwpProcess* proc;
|
|
|
|
do {
|
|
s = adb_socket_accept( control->listen_socket, &addr, &addrlen );
|
|
if (s < 0) {
|
|
if (errno == EINTR)
|
|
continue;
|
|
if (errno == ECONNABORTED) {
|
|
/* oops, the JDWP process died really quick */
|
|
D("oops, the JDWP process died really quick");
|
|
return;
|
|
}
|
|
/* the socket is probably closed ? */
|
|
D( "weird accept() failed on jdwp control socket: %s",
|
|
strerror(errno) );
|
|
return;
|
|
}
|
|
}
|
|
while (s < 0);
|
|
|
|
proc = jdwp_process_alloc( s );
|
|
if (proc == NULL)
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
static JdwpControl _jdwp_control;
|
|
|
|
/** "jdwp" local service implementation
|
|
** this simply returns the list of known JDWP process pids
|
|
**/
|
|
|
|
struct JdwpSocket {
|
|
asocket socket;
|
|
int pass;
|
|
};
|
|
|
|
static void
|
|
jdwp_socket_close( asocket* s )
|
|
{
|
|
asocket* peer = s->peer;
|
|
|
|
remove_socket(s);
|
|
|
|
if (peer) {
|
|
peer->peer = NULL;
|
|
peer->close(peer);
|
|
}
|
|
free(s);
|
|
}
|
|
|
|
static int
|
|
jdwp_socket_enqueue( asocket* s, apacket* p )
|
|
{
|
|
/* you can't write to this asocket */
|
|
put_apacket(p);
|
|
s->peer->close(s->peer);
|
|
return -1;
|
|
}
|
|
|
|
|
|
static void
|
|
jdwp_socket_ready( asocket* s )
|
|
{
|
|
JdwpSocket* jdwp = (JdwpSocket*)s;
|
|
asocket* peer = jdwp->socket.peer;
|
|
|
|
/* on the first call, send the list of pids,
|
|
* on the second one, close the connection
|
|
*/
|
|
if (jdwp->pass == 0) {
|
|
apacket* p = get_apacket();
|
|
p->len = jdwp_process_list((char*)p->data, s->get_max_payload());
|
|
peer->enqueue(peer, p);
|
|
jdwp->pass = 1;
|
|
}
|
|
else {
|
|
peer->close(peer);
|
|
}
|
|
}
|
|
|
|
asocket*
|
|
create_jdwp_service_socket( void )
|
|
{
|
|
JdwpSocket* s = reinterpret_cast<JdwpSocket*>(calloc(sizeof(*s), 1));
|
|
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
install_local_socket(&s->socket);
|
|
|
|
s->socket.ready = jdwp_socket_ready;
|
|
s->socket.enqueue = jdwp_socket_enqueue;
|
|
s->socket.close = jdwp_socket_close;
|
|
s->pass = 0;
|
|
|
|
return &s->socket;
|
|
}
|
|
|
|
/** "track-jdwp" local service implementation
|
|
** this periodically sends the list of known JDWP process pids
|
|
** to the client...
|
|
**/
|
|
|
|
struct JdwpTracker {
|
|
asocket socket;
|
|
JdwpTracker* next;
|
|
JdwpTracker* prev;
|
|
int need_update;
|
|
};
|
|
|
|
static JdwpTracker _jdwp_trackers_list;
|
|
|
|
|
|
static void
|
|
jdwp_process_list_updated(void)
|
|
{
|
|
char buffer[1024];
|
|
int len;
|
|
JdwpTracker* t = _jdwp_trackers_list.next;
|
|
|
|
len = jdwp_process_list_msg(buffer, sizeof(buffer));
|
|
|
|
for ( ; t != &_jdwp_trackers_list; t = t->next ) {
|
|
apacket* p = get_apacket();
|
|
asocket* peer = t->socket.peer;
|
|
memcpy(p->data, buffer, len);
|
|
p->len = len;
|
|
peer->enqueue( peer, p );
|
|
}
|
|
}
|
|
|
|
static void
|
|
jdwp_tracker_close( asocket* s )
|
|
{
|
|
JdwpTracker* tracker = (JdwpTracker*) s;
|
|
asocket* peer = s->peer;
|
|
|
|
if (peer) {
|
|
peer->peer = NULL;
|
|
peer->close(peer);
|
|
}
|
|
|
|
remove_socket(s);
|
|
|
|
tracker->prev->next = tracker->next;
|
|
tracker->next->prev = tracker->prev;
|
|
|
|
free(s);
|
|
}
|
|
|
|
static void
|
|
jdwp_tracker_ready( asocket* s )
|
|
{
|
|
JdwpTracker* t = (JdwpTracker*) s;
|
|
|
|
if (t->need_update) {
|
|
apacket* p = get_apacket();
|
|
t->need_update = 0;
|
|
p->len = jdwp_process_list_msg((char*)p->data, s->get_max_payload());
|
|
s->peer->enqueue(s->peer, p);
|
|
}
|
|
}
|
|
|
|
static int
|
|
jdwp_tracker_enqueue( asocket* s, apacket* p )
|
|
{
|
|
/* you can't write to this socket */
|
|
put_apacket(p);
|
|
s->peer->close(s->peer);
|
|
return -1;
|
|
}
|
|
|
|
|
|
asocket*
|
|
create_jdwp_tracker_service_socket( void )
|
|
{
|
|
JdwpTracker* t = reinterpret_cast<JdwpTracker*>(calloc(sizeof(*t), 1));
|
|
|
|
if (t == NULL)
|
|
return NULL;
|
|
|
|
t->next = &_jdwp_trackers_list;
|
|
t->prev = t->next->prev;
|
|
|
|
t->next->prev = t;
|
|
t->prev->next = t;
|
|
|
|
install_local_socket(&t->socket);
|
|
|
|
t->socket.ready = jdwp_tracker_ready;
|
|
t->socket.enqueue = jdwp_tracker_enqueue;
|
|
t->socket.close = jdwp_tracker_close;
|
|
t->need_update = 1;
|
|
|
|
return &t->socket;
|
|
}
|
|
|
|
|
|
int
|
|
init_jdwp(void)
|
|
{
|
|
_jdwp_list.next = &_jdwp_list;
|
|
_jdwp_list.prev = &_jdwp_list;
|
|
|
|
_jdwp_trackers_list.next = &_jdwp_trackers_list;
|
|
_jdwp_trackers_list.prev = &_jdwp_trackers_list;
|
|
|
|
return jdwp_control_init( &_jdwp_control,
|
|
JDWP_CONTROL_NAME,
|
|
JDWP_CONTROL_NAME_LEN );
|
|
}
|
|
|
|
#endif /* !ADB_HOST */
|