int ini_server(const char * url, Protocol * p, TCFBroadcastGroup * b) {
ChannelServer * serv = NULL;
PeerServer * ps = NULL;
Trap trap;
if (!set_trap(&trap)) {
bcg = NULL;
proto = NULL;
if (ps != NULL) peer_server_free(ps);
errno = trap.error;
return -1;
}
bcg = b;
proto = p;
ps = channel_peer_from_url(url);
if (ps == NULL) str_exception(ERR_OTHER, "Invalid server URL");
peer_server_addprop(ps, loc_strdup("Name"), loc_strdup(PROXY_NAME));
peer_server_addprop(ps, loc_strdup("Proxy"), loc_strdup(""));
SERVER_ADDPROP_HOOK;
serv = channel_server(ps);
if (serv == NULL) exception(errno);
serv->new_conn = channel_new_connection;
clear_trap(&trap);
add_channel_redirection_listener(channel_redirection_listener);
return 0;
}
/*
void remove_port_redirection(PortServer * redir) {
port_server_shutdown(redir->server);
}
*/
PortServer * create_port_redirection(PortRedirectionInfo * port) {
PortServer * server;
assert (port != NULL);
assert (port->c != NULL);
if (port == NULL || port->c == NULL) {
free_port_redirection_info(port);
errno = EINVAL;
return NULL;
}
ini_portforwarding();
/* We do not accept specifying a target_port (legacy) and port attributes */
if (port->target_port != 0 && port->attrs != NULL) {
free_port_redirection_info(port);
errno = EINVAL;
return NULL;
}
if (port->target_port != 0) {
char port_str[16];
PortAttribute * attr = (PortAttribute *)loc_alloc_zero(sizeof(PortAttribute));
snprintf(port_str, 16, "%d", port->target_port);
attr->name = loc_strdup("Port");
attr->value = loc_strdup(port_str);
attr->next = port->attrs;
port->attrs = attr;
}
server = create_port_server(port->c, port);
if (server == NULL) {
free_port_redirection_info(port);
loc_free(server);
return NULL;
}
else {
server->redir_info = port;
port->local_port = server->local_port;
server->auto_connect = port->auto_connect;
server->auto_connect_period = port->auto_connect_period == 0 ? 3 : port->auto_connect_period;
server->connect_callback = port->connect_callback;
server->disconnect_callback = port->disconnect_callback;
server->recv_callback = port->recv_callback;
server->callback_data = port->callback_data;
if (server->auto_connect) {
/* If auto connect mode is set, immediately try to connect to the
* port.
*/
port_connection_open(server, server->is_udp ? server->sock : -1);
}
return server;
}
}
static int lua_peer_setvalue(lua_State *L)
{
struct peer_extra *pse = NULL;
assert(L == luastate);
if(lua_gettop(L) != 3 || (pse = lua2peer(L, 1)) == NULL ||
!lua_isstring(L, 2) || !lua_isstring(L, 3)) {
luaL_error(L, "wrong number or type of arguments");
}
if(pse->ps == NULL) luaL_error(L, "stale peer");
trace(LOG_LUA, "lua_peer_setvalue %p", pse->ps);
peer_server_addprop(pse->ps, loc_strdup(lua_tostring(L, 2)), loc_strdup(lua_tostring(L, 3)));
return 0;
}
static void add_map_region(MemoryMap * map, void * addr, int size, unsigned flags, char * file, char * sect) {
MemoryRegion * r = NULL;
if (map->region_cnt >= map->region_max) {
map->region_max += 8;
map->regions = (MemoryRegion *)loc_realloc(map->regions, sizeof(MemoryRegion) * map->region_max);
}
r = map->regions + map->region_cnt++;
memset(r, 0, sizeof(MemoryRegion));
r->addr = (ContextAddress)addr;
r->size = (ContextAddress)size;
r->flags = flags;
if (file != NULL) r->file_name = loc_strdup(file);
if (sect != NULL) r->sect_name = loc_strdup(sect);
}
static void ini_reg_defs(void) {
RegisterDefinition * d;
regs_cnt = 0;
regs_max = 800;
regs_index = (RegisterDefinition *)loc_alloc_zero(sizeof(RegisterDefinition) * regs_max);
for (d = regs_def; d->name != NULL; d++) {
RegisterDefinition * r = alloc_reg();
assert(d->parent == NULL);
*r = *d;
if (strcmp(r->name, "sp") == 0) {
r->role = "SP";
}
else if (strcmp(r->name, "pc") == 0) {
r->role = "PC";
pc_def = r;
}
else if (strcmp(r->name, "r0") == 0) {
unsigned i;
for (i = 1; i < 31; i++) {
char name[64];
r = alloc_reg();
*r = *d;
snprintf(name, sizeof(name), "r%d", i);
r->name = loc_strdup(name);
r->offset = d->offset + i * 8;
r->dwarf_id = d->dwarf_id + i;
r->eh_frame_id = d->eh_frame_id + i;
}
}
}
}
static void add_report_prop(ReportBuffer * report, const char * name, ByteArrayOutputStream * buf) {
ErrorReportItem * i = (ErrorReportItem *)loc_alloc(sizeof(ErrorReportItem));
i->name = loc_strdup(name);
get_byte_array_output_stream_data(buf, &i->value, NULL);
i->next = report->pub.props;
report->pub.props = i;
}
static void read_port_server_property(InputStream * inp, const char * name,
void * args) {
PortAttribute ** attrs = (PortAttribute **) args;
PortAttribute * attr = (PortAttribute *)loc_alloc_zero(sizeof(PortAttribute));
attr->value = json_read_object(inp);
attr->name = loc_strdup(name);
attr->next = *attrs;
*attrs = attr;
}
void add_reset(Context * ctx, const char * type, const char * desc, ContextReset * reset) {
ContextExtensionRS * ext = EXT(ctx);
ResetInfo * ri;
ri = find_reset(ctx, type);
if (ri == NULL) {
if (ext->resets_cnt >= ext->resets_max) {
ext->resets_max += 4;
ext->resets = (ResetInfo *)loc_realloc(ext->resets, sizeof(ResetInfo) * ext->resets_max);
}
ri = ext->resets + ext->resets_cnt++;
ri->type = loc_strdup(type);
}
else {
loc_free(ri->desc);
}
ri->desc = loc_strdup(desc);
ri->reset = reset;
}
static int lua_peer_server_from_url(lua_State *L)
{
PeerServer *ps;
const char *url;
assert(L == luastate);
if(lua_gettop(L) != 1 || !lua_isstring(L, 1)) {
luaL_error(L, "wrong number or type of arguments");
}
url = lua_tostring(L, 1);
ps = channel_peer_from_url(url);
trace(LOG_LUA, "lua_peer_server_from_url %s %p", url, ps);
if(ps == NULL) luaL_error(L, "cannot parse url: %s", lua_tostring(L, 1));
if(ps->id == NULL) {
peer_server_addprop(ps, loc_strdup("ID"), loc_strdup(lua_tostring(L, 1)));
}
lua_alloc_pse(L, ps);
return 1;
}
static void set_peer_addr(ChannelNP * c, struct sockaddr * addr, int addr_len) {
/* Create a human readable channel name that uniquely identifies remote peer */
char name[128];
char nbuf[128];
assert(addr->sa_family == AF_INET);
snprintf(name, sizeof(name), "%s:%s:%d",
c->is_ssl ? "WSS" : "WS",
inet_ntop(addr->sa_family,
&((struct sockaddr_in *)addr)->sin_addr, nbuf, sizeof(nbuf)),
ntohs(((struct sockaddr_in *)addr)->sin_port));
c->chan.peer_name = loc_strdup(name);
}
static void read_port_server_property(InputStream * inp, const char * name,
void * args) {
PortRedirectionInfo * port = args;
if (strcmp(name, "LocalPort") == 0) port->local_port =
(unsigned int) json_read_uint64(inp);
else {
PortAttribute * attr = (PortAttribute *)loc_alloc_zero(sizeof(PortAttribute));
attr->value = json_read_object(inp);
attr->name = loc_strdup(name);
attr->next = port->attrs;
port->attrs = attr;
}
}
int set_errno(int no, const char * msg) {
errno = no;
if (no != 0 && msg != NULL) {
ErrorMessage * m = alloc_msg(SRC_MESSAGE);
/* alloc_msg() assigns new value to 'errno',
* need to be sure it does not change until this function exits.
*/
int err = errno;
m->error = get_error_code(no);
if (no == ERR_OTHER) {
m->text = loc_strdup(msg);
}
else {
size_t msg_len = strlen(msg);
if (msg_len == 0) {
m->text = loc_strdup(errno_to_str(no));
}
else {
const char * text0 = tmp_strdup(msg);
const char * text1 = errno_to_str(no);
if (text0[msg_len - 1] == '.' || text0[msg_len - 1] == '\n') {
size_t len = msg_len + strlen(text1) + 2;
char * text2 = (char *)loc_alloc(len);
snprintf(text2, len, "%s %s", text0, text1);
m->text = text2;
}
else {
size_t len = msg_len + strlen(text1) + 3;
char * text2 = (char *)loc_alloc(len);
snprintf(text2, len, "%s. %s", text0, text1);
m->text = text2;
}
}
}
errno = err;
}
return errno;
}
int parse_socks_v5_proxy(const char * proxy) {
if (proxy != NULL) {
const char * str;
str = strchr(proxy, ':');
if (str == NULL || strchr (str + 1, ':') != NULL) {
set_errno (ERR_OTHER, "Invalid format for SocksV5 WebSocket proxy");
return -1;
}
socks_v5_host = loc_alloc_zero(str - proxy + 1);
strncpy(socks_v5_host, proxy, str - proxy);
socks_v5_port = loc_strdup(str + 1);
}
return 0;
}
static void read_reset_params(InputStream * inp, const char * name, void * x) {
ResetParams * params = (ResetParams *)x;
if (strcmp(name, "Suspend") == 0) {
params->suspend = json_read_boolean(inp);
}
else {
ResetParameter * param = (ResetParameter *)loc_alloc_zero(sizeof(ResetParameter));
param->name = loc_strdup(name);
param->value = json_read_object(inp);
param->next = params->list;
params->list = param;
}
}
void add_disassembler(Context * ctx, const char * isa, Disassembler disassembler) {
DisassemblerInfo * i = NULL;
ContextExtensionDS * ext = EXT(ctx);
assert(ctx == context_get_group(ctx, CONTEXT_GROUP_CPU));
if ((i = find_disassembler_info(ctx, isa)) == NULL) {
if (ext->disassemblers_cnt >= ext->disassemblers_max) {
ext->disassemblers_max += 8;
ext->disassemblers = (DisassemblerInfo *)loc_realloc(ext->disassemblers,
sizeof(DisassemblerInfo) * ext->disassemblers_max);
}
i = ext->disassemblers + ext->disassemblers_cnt++;
i->isa = loc_strdup(isa);
}
i->disassembler = disassembler;
}
int plugin_add_function(const char * name, void * function) {
size_t i;
if (!name || !function) return -EINVAL;
/* Check if the function name already exists */
for (i = 0; i < function_entry_count; ++i)
if (!strcmp(name, function_entries[i].name))
return -EEXIST;
function_entries = (struct function_entry *) loc_realloc(function_entries,
++function_entry_count * sizeof(struct function_entry));
function_entries[function_entry_count-1].function = function;
function_entries[function_entry_count-1].name = loc_strdup(name);
return 0;
}
static int np_wt_read_request (void * args) {
NpIOReq * req = (NpIOReq *)args;
int rval = 0;
trace(LOG_PROTOCOL, "read request size:%d",req->bufsz);
while (rval == 0) {
rval = nopoll_conn_read (req->np_sock, req->bufp, req->bufsz, nopoll_false, 10);
if ((rval <= 0) && !nopoll_conn_is_ok(req->np_sock)) {
rval = 0; /* Treat error as EOF */
break;
}
else if (rval < 0) {
errno = ERR_OTHER;
req->error_msg = loc_strdup("Failure reading socket");
break;
}
}
trace(LOG_PROTOCOL, "read size:%d",rval);
return rval;
}
static MemoryMap * get_memory_map(Context * ctx) {
char maps_file_name[FILE_PATH_SIZE];
MemoryMap * map = NULL;
FILE * file;
if (ctx->pid != ctx->mem) ctx = ctx->parent;
assert(ctx->pid == ctx->mem);
if (ctx->memory_map != NULL) return (MemoryMap *)ctx->memory_map;
snprintf(maps_file_name, sizeof(maps_file_name), "/proc/%d/maps", ctx->pid);
if ((file = fopen(maps_file_name, "r")) == NULL) return NULL;
map = loc_alloc_zero(sizeof(MemoryMap));
for (;;) {
unsigned long addr0 = 0;
unsigned long addr1 = 0;
unsigned long offset = 0;
unsigned long dev_ma = 0;
unsigned long dev_mi = 0;
unsigned long inode = 0;
char permissions[16];
char file_name[FILE_PATH_SIZE];
MemoryRegion * r = NULL;
unsigned i = 0;
int cnt = fscanf(file, "%lx-%lx %s %lx %lx:%lx %ld",
&addr0, &addr1, permissions, &offset, &dev_ma, &dev_mi, &inode);
if (cnt == 0 || cnt == EOF) break;
for (;;) {
int ch = fgetc(file);
if (ch == '\n' || ch == EOF) break;
if (i < FILE_PATH_SIZE - 1 && (ch != ' ' || i > 0)) {
file_name[i++] = ch;
}
}
file_name[i++] = 0;
if (map->region_cnt >= map->region_max) {
map->region_max += 8;
map->regions = (MemoryRegion *)loc_realloc(map->regions, sizeof(MemoryRegion) * map->region_max);
}
r = map->regions + map->region_cnt++;
memset(r, 0, sizeof(MemoryRegion));
r->addr = addr0;
r->size = addr1 - addr0;
r->file_offs = offset;
r->dev = MKDEV(dev_ma, dev_mi);
r->ino = (ino_t)inode;
if (inode != 0 && file_name[0]) {
r->file_name = loc_strdup(file_name);
}
for (i = 0; permissions[i]; i++) {
switch (permissions[i]) {
case 'r': r->flags |= MM_FLAG_R; break;
case 'w': r->flags |= MM_FLAG_W; break;
case 'x': r->flags |= MM_FLAG_X; break;
}
}
}
fclose(file);
ctx->memory_map = map;
return map;
}
ErrorReport * get_error_report(int err) {
ErrorMessage * m = NULL;
if (err >= ERR_MESSAGE_MIN && err <= ERR_MESSAGE_MAX) {
assert(is_dispatch_thread());
m = msgs + (err - ERR_MESSAGE_MIN);
if (m->report != NULL) {
m->report->refs++;
m->report->gets++;
return &m->report->pub;
}
}
if (err != 0) {
ReportBuffer * report = (ReportBuffer *)loc_alloc_zero(sizeof(ReportBuffer));
struct timespec timenow;
if (clock_gettime(CLOCK_REALTIME, &timenow) == 0) {
report->pub.time_stamp = (uint64_t)timenow.tv_sec * 1000 + timenow.tv_nsec / 1000000;
}
report->pub.format = loc_strdup(errno_to_str(err));
#if defined(_WIN32) || defined(__CYGWIN__)
if (err >= ERR_WINDOWS_MIN && err <= ERR_WINDOWS_MAX) {
add_report_prop_int(report, "AltCode", err - ERR_WINDOWS_MIN);
add_report_prop_str(report, "AltOrg", "_WIN32");
err = ERR_OTHER;
}
#endif
if (m != NULL) {
if (m->source == SRC_MESSAGE) {
err = m->error;
}
else {
err = ERR_OTHER;
}
}
if (err < STD_ERR_BASE || err > ERR_MESSAGE_MAX) {
report->posix_code = err;
add_report_prop_int(report, "AltCode", err);
#if defined(_MSC_VER)
add_report_prop_str(report, "AltOrg", "MSC");
#elif defined(_WRS_KERNEL)
add_report_prop_str(report, "AltOrg", "VxWorks");
#elif defined(__CYGWIN__)
add_report_prop_str(report, "AltOrg", "CygWin");
#elif defined(__linux__)
add_report_prop_str(report, "AltOrg", "Linux");
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
add_report_prop_str(report, "AltOrg", "BSD");
#elif defined(__SYMBIAN32__)
add_report_prop_str(report, "AltOrg", "Symbian");
#else
add_report_prop_str(report, "AltOrg", "POSIX");
#endif
err = ERR_OTHER;
}
assert(err >= STD_ERR_BASE);
assert(err < ERR_MESSAGE_MIN);
report->pub.code = err - STD_ERR_BASE;
report->refs = 1;
report->gets = 1;
if (m != NULL) {
assert(m->report == NULL);
m->report = report;
report->refs++;
}
return &report->pub;
}
return NULL;
}
static void * worker_thread_handler(void * x) {
WorkerThread * wt = (WorkerThread *)x;
for (;;) {
AsyncReqInfo * req = wt->req;
assert(req != NULL);
req->error = 0;
switch(req->type) {
case AsyncReqTimer:
#if defined(_WIN32) && !defined(__CYGWIN__)
Sleep(EVENTS_TIMER_RESOLUTION);
events_timer_ms = GetTickCount();
#else
{
struct timespec timenow;
usleep(EVENTS_TIMER_RESOLUTION * 1000);
if (clock_gettime(CLOCK_REALTIME, &timenow) == 0) {
events_timer_ms = (uint32_t)(timenow.tv_nsec / 1000000 + timenow.tv_sec * 1000);
}
}
#endif
break;
case AsyncReqRead: /* File read */
req->u.fio.rval = read(req->u.fio.fd, req->u.fio.bufp, req->u.fio.bufsz);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqWrite: /* File write */
req->u.fio.rval = write(req->u.fio.fd, req->u.fio.bufp, req->u.fio.bufsz);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqSeekRead: /* File read at offset */
req->u.fio.rval = pread(req->u.fio.fd, req->u.fio.bufp, req->u.fio.bufsz, (off_t)req->u.fio.offset);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqSeekWrite: /* File write at offset */
req->u.fio.rval = pwrite(req->u.fio.fd, req->u.fio.bufp, req->u.fio.bufsz, (off_t)req->u.fio.offset);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqRecv: /* Socket recv */
req->u.sio.rval = recv(req->u.sio.sock, req->u.sio.bufp, req->u.sio.bufsz, req->u.sio.flags);
if (req->u.sio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqSend: /* Socket send */
req->u.sio.rval = send(req->u.sio.sock, req->u.sio.bufp, req->u.sio.bufsz, req->u.sio.flags);
if (req->u.sio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqRecvFrom: /* Socket recvfrom */
req->u.sio.rval = recvfrom(req->u.sio.sock, req->u.sio.bufp, req->u.sio.bufsz, req->u.sio.flags, req->u.sio.addr, &req->u.sio.addrlen);
if (req->u.sio.rval == -1) {
req->error = errno;
trace(LOG_ASYNCREQ, "AsyncReqRecvFrom: req %p, type %d, error %d", req, req->type, req->error);
assert(req->error);
}
break;
case AsyncReqSendTo: /* Socket sendto */
req->u.sio.rval = sendto(req->u.sio.sock, req->u.sio.bufp, req->u.sio.bufsz, req->u.sio.flags, req->u.sio.addr, req->u.sio.addrlen);
if (req->u.sio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqAccept: /* Accept socket connections */
req->u.acc.rval = accept(req->u.acc.sock, req->u.acc.addr, req->u.acc.addr ? &req->u.acc.addrlen : NULL);
if (req->u.acc.rval == -1) {
req->error = errno;
trace(LOG_ASYNCREQ, "AsyncReqAccept: req %p, type %d, error %d", req, req->type, req->error);
assert(req->error);
}
break;
case AsyncReqConnect: /* Connect to socket */
req->u.con.rval = connect(req->u.con.sock, req->u.con.addr, req->u.con.addrlen);
if (req->u.con.rval == -1) {
req->error = errno;
trace(LOG_ASYNCREQ, "AsyncReqConnect: req %p, type %d, error %d", req, req->type, req->error);
assert(req->error);
}
break;
/* Platform dependant IO methods */
#if defined(_WIN32) || defined(__CYGWIN__)
case AsyncReqConnectPipe:
req->u.cnp.rval = ConnectNamedPipe(req->u.cnp.pipe, NULL);
if (!req->u.cnp.rval) {
req->error = set_win32_errno(GetLastError());
assert(req->error);
}
break;
#elif defined(_WRS_KERNEL)
#else
case AsyncReqWaitpid: /* Wait for process change */
req->u.wpid.rval = waitpid(req->u.wpid.pid, &req->u.wpid.status, req->u.wpid.options);
if (req->u.wpid.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
#endif
case AsyncReqSelect:
{
struct timeval tv;
tv.tv_sec = (long)req->u.select.timeout.tv_sec;
tv.tv_usec = req->u.select.timeout.tv_nsec / 1000;
req->u.select.rval = select(req->u.select.nfds, &req->u.select.readfds,
&req->u.select.writefds, &req->u.select.errorfds, &tv);
if (req->u.select.rval == -1) {
req->error = errno;
assert(req->error);
}
}
break;
case AsyncReqClose:
req->u.fio.rval = close(req->u.fio.fd);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqCloseDir:
req->u.dio.rval = closedir((DIR *)req->u.dio.dir);
if (req->u.dio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqOpen:
req->u.fio.rval = open(req->u.fio.file_name, req->u.fio.flags, req->u.fio.permission);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqOpenDir:
req->u.dio.dir = opendir(req->u.dio.path);
if (req->u.dio.dir == NULL) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqFstat:
memset(&req->u.fio.statbuf, 0, sizeof(req->u.fio.statbuf));
req->u.fio.rval = fstat(req->u.fio.fd, &req->u.fio.statbuf);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
#if defined(_WIN32) || defined(__CYGWIN__)
req->u.fio.win32_attrs = req->error || !req->u.fio.file_name ?
INVALID_FILE_ATTRIBUTES : GetFileAttributes(req->u.fio.file_name);
#endif
break;
case AsyncReqStat:
memset(&req->u.fio.statbuf, 0, sizeof(req->u.fio.statbuf));
req->u.fio.rval = stat(req->u.fio.file_name, &req->u.fio.statbuf);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
#if defined(_WIN32) || defined(__CYGWIN__)
req->u.fio.win32_attrs = req->error ?
INVALID_FILE_ATTRIBUTES : GetFileAttributes(req->u.fio.file_name);
#endif
break;
case AsyncReqLstat:
memset(&req->u.fio.statbuf, 0, sizeof(req->u.fio.statbuf));
req->u.fio.rval = lstat(req->u.fio.file_name, &req->u.fio.statbuf);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
#if defined(_WIN32) || defined(__CYGWIN__)
req->u.fio.win32_attrs = req->error ?
INVALID_FILE_ATTRIBUTES : GetFileAttributes(req->u.fio.file_name);
#endif
break;
case AsyncReqSetStat:
{
int err = 0;
if (req->u.fio.set_stat_flags & AsyncReqSetSize) {
if (truncate(req->u.fio.file_name, (off_t)req->u.fio.statbuf.st_size) < 0) err = errno;
}
if (req->u.fio.set_stat_flags & AsyncReqSetPermissions) {
if (chmod(req->u.fio.file_name, req->u.fio.statbuf.st_mode) < 0) err = errno;
}
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WRS_KERNEL)
# if defined(_WIN32) || defined(__CYGWIN__)
if (req->u.fio.win32_attrs != INVALID_FILE_ATTRIBUTES) {
if (SetFileAttributes(req->u.fio.file_name, req->u.fio.win32_attrs) == 0)
err = set_win32_errno(GetLastError());
}
# endif
#else
if (req->u.fio.set_stat_flags & AsyncReqSetUidGid) {
if (chown(req->u.fio.file_name, req->u.fio.statbuf.st_uid, req->u.fio.statbuf.st_gid) < 0) err = errno;
}
#endif
if (req->u.fio.set_stat_flags & AsyncReqSetAcModTime) {
struct utimbuf buf;
buf.actime = req->u.fio.statbuf.st_atime;
buf.modtime = req->u.fio.statbuf.st_mtime;
if (utime(req->u.fio.file_name, &buf) < 0) err = errno;
}
req->error = err;
}
break;
case AsyncReqFSetStat:
{
int err = 0;
if (req->u.fio.set_stat_flags & AsyncReqSetSize) {
if (ftruncate(req->u.fio.fd, (off_t)req->u.fio.statbuf.st_size) < 0) err = errno;
}
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WRS_KERNEL)
if (req->u.fio.set_stat_flags & AsyncReqSetPermissions) {
if (chmod(req->u.fio.file_name, req->u.fio.statbuf.st_mode) < 0) err = errno;
}
# if defined(_WIN32) || defined(__CYGWIN__)
if (req->u.fio.win32_attrs != INVALID_FILE_ATTRIBUTES) {
if (SetFileAttributes(req->u.fio.file_name, req->u.fio.win32_attrs) == 0)
err = set_win32_errno(GetLastError());
}
# endif
#else
if (req->u.fio.set_stat_flags & AsyncReqSetUidGid) {
if (fchown(req->u.fio.fd, req->u.fio.statbuf.st_uid, req->u.fio.statbuf.st_gid) < 0) err = errno;
}
if (req->u.fio.set_stat_flags & AsyncReqSetPermissions) {
if (fchmod(req->u.fio.fd, req->u.fio.statbuf.st_mode) < 0) err = errno;
}
#endif
if (req->u.fio.set_stat_flags & AsyncReqSetAcModTime) {
struct utimbuf buf;
buf.actime = req->u.fio.statbuf.st_atime;
buf.modtime = req->u.fio.statbuf.st_mtime;
#if defined(_WIN32) && !defined(__MINGW32__)
if (futime(req->u.fio.fd, &buf) < 0) err = errno;
#else
if (utime(req->u.fio.file_name, &buf) < 0) err = errno;
#endif
}
req->error = err;
}
break;
case AsyncReqRemove:
req->u.fio.rval = remove(req->u.fio.file_name);
if (req->u.fio.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
case AsyncReqReadDir:
{
int cnt = 0;
while (cnt < req->u.dio.max_files) {
char path[FILE_PATH_SIZE];
struct DirFileNode * file = req->u.dio.files + cnt;
struct dirent * e;
struct stat st;
errno = 0;
e = readdir((DIR *)req->u.dio.dir);
if (e == NULL) {
req->error = errno;
if (req->error == 0) req->u.dio.eof = 1;
break;
}
if (strcmp(e->d_name, ".") == 0) continue;
if (strcmp(e->d_name, "..") == 0) continue;
file->path = loc_strdup(e->d_name);
memset(&st, 0, sizeof(st));
snprintf(path, sizeof(path), "%s/%s", req->u.dio.path, e->d_name);
if (stat(path, &st) == 0) {
#if defined(_WIN32) || defined(__CYGWIN__)
file->win32_attrs = GetFileAttributes(path);
#endif
file->statbuf = (struct stat *)loc_alloc(sizeof(struct stat));
memcpy(file->statbuf, &st, sizeof(struct stat));
}
cnt++;
}
}
break;
case AsyncReqRoots:
{
struct stat st;
struct RootDevNode * newDevNode = NULL;
#if defined(_WIN32) || defined(__CYGWIN__)
{
struct RootDevNode * curDevNode = NULL;
int disk = 0;
DWORD disks = GetLogicalDrives();
for (disk = 0; disk <= 30; disk++) {
if (disks & (1 << disk)) {
char path[32];
newDevNode = (struct RootDevNode *)loc_alloc_zero(sizeof(struct RootDevNode));
if (curDevNode == NULL) req->u.root.lst = newDevNode;
else curDevNode->next = newDevNode;
curDevNode = newDevNode;
snprintf(path, sizeof(path), "%c:\\", 'A' + disk);
newDevNode->devname = loc_strdup(path);
if (disk >= 2) {
ULARGE_INTEGER total_number_of_bytes;
BOOL has_size = GetDiskFreeSpaceExA(path, NULL, &total_number_of_bytes, NULL);
memset(&st, 0, sizeof(st));
#if defined(__CYGWIN__)
snprintf(path, sizeof(path), "/cygdrive/%c", 'a' + disk);
#endif
if (has_size && stat(path, &st) == 0) {
newDevNode->win32_attrs = GetFileAttributes(path);
newDevNode->statbuf = (struct stat *)loc_alloc_zero(sizeof(struct stat));
memcpy(newDevNode->statbuf, &st, sizeof(struct stat));
}
}
}
}
}
#elif defined(_WRS_KERNEL)
{
struct RootDevNode * curDevNode = NULL;
extern DL_LIST iosDvList;
DEV_HDR * dev;
for (dev = (DEV_HDR *)DLL_FIRST(&iosDvList); dev != NULL; dev = (DEV_HDR *)DLL_NEXT(&dev->node)) {
char path[FILE_PATH_SIZE];
if (strcmp(dev->name, "host:") == 0) {
/* Windows host is special case */
int d;
for (d = 'a'; d < 'z'; d++) {
snprintf(path, sizeof(path), "%s%c:/", dev->name, d);
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
newDevNode = (struct RootDevNode *)loc_alloc_zero(sizeof(struct RootDevNode));
if (curDevNode == NULL) req->u.root.lst = newDevNode;
else curDevNode->next = newDevNode;
curDevNode = newDevNode;
newDevNode->devname = loc_strdup(path);
newDevNode->statbuf = (struct stat *)loc_alloc_zero(sizeof(struct stat));
memcpy(newDevNode->statbuf, &st, sizeof(struct stat));
}
}
}
snprintf(path, sizeof(path), "%s/", dev->name);
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
newDevNode = (struct RootDevNode *)loc_alloc_zero(sizeof(struct RootDevNode));
if (curDevNode == NULL) req->u.root.lst = newDevNode;
else curDevNode->next = newDevNode;
curDevNode = newDevNode;
newDevNode->devname = loc_strdup(path);
newDevNode->statbuf = (struct stat *)loc_alloc_zero(sizeof(struct stat));
memcpy(newDevNode->statbuf, &st, sizeof(struct stat));
}
}
}
#else
req->u.root.lst = newDevNode = (struct RootDevNode *)loc_alloc_zero(sizeof(struct RootDevNode));
newDevNode->devname = loc_strdup("/");
if (stat("/", &st) == 0) {
newDevNode->statbuf = (struct stat *)loc_alloc_zero(sizeof(struct stat));
memcpy(newDevNode->statbuf, &st, sizeof(struct stat));
}
#endif
}
break;
case AsyncReqUser: /* User defined request */
req->u.user.rval = req->u.user.func(req->u.user.data);
if (req->u.user.rval == -1) {
req->error = errno;
assert(req->error);
}
break;
default:
req->error = ENOSYS;
break;
}
if (req->type == AsyncReqTimer) {
if (async_shutdown.state == SHUTDOWN_STATE_PENDING) break;
continue;
}
trace(LOG_ASYNCREQ, "async_req_complete: req %p, type %d, error %d", req, req->type, req->error);
check_error(pthread_mutex_lock(&wtlock));
/* Post event inside lock to make sure a new worker thread is not created unnecessarily */
post_event(req->done, req);
wt->req = NULL;
if (wtlist_size >= MAX_WORKER_THREADS || async_shutdown.state == SHUTDOWN_STATE_PENDING) {
check_error(pthread_mutex_unlock(&wtlock));
break;
}
list_add_last(&wt->wtlink, &wtlist);
wtlist_size++;
for (;;) {
check_error(pthread_cond_wait(&wt->cond, &wtlock));
if (wt->req != NULL) break;
}
check_error(pthread_mutex_unlock(&wtlock));
if (wt->req == &shutdown_req) break;
}
post_event(worker_thread_exit, wt);
return NULL;
}
int tcf_log(void) {
#else
int main(int argc, char ** argv) {
int c;
int ind;
const char * log_name = "-";
#endif
const char * url = "TCP:";
PeerServer * ps;
ChannelServer * serv;
int print_server_properties = 0;
ini_mdep();
ini_trace();
ini_events_queue();
ini_asyncreq();
log_mode = LOG_TCFLOG;
#if defined(_WRS_KERNEL)
progname = "tcf";
open_log_file("-");
#else
progname = argv[0];
/* Parse arguments */
for (ind = 1; ind < argc; ind++) {
char * s = argv[ind];
if (*s++ != '-') break;
while (s && (c = *s++) != '\0') {
switch (c) {
case 'h':
show_help();
exit(0);
case 'n':
auto_redirect = 0;
break;
case 'S':
print_server_properties = 1;
break;
#if ENABLE_Trace
case 'l':
#endif
case 'L':
case 's':
case 'f':
if (*s == '\0') {
if (++ind >= argc) {
fprintf(stderr, "%s: error: no argument given to option '%c'\n", progname, c);
exit(1);
}
s = argv[ind];
}
switch (c) {
#if ENABLE_Trace
case 'l':
if (parse_trace_mode(s, &log_mode) != 0) {
fprintf(stderr, "Cannot parse log level: %s\n", s);
exit(1);
}
break;
#endif
case 'L':
log_name = s;
break;
case 's':
url = s;
break;
case 'f':
if (filter_add_message_filter(s) != 0) {
fprintf(stderr, "Cannot parse filter level: %s\n", s);
exit(1);
}
break;
default:
fprintf(stderr, "%s: error: illegal option '%c'\n", progname, c);
show_help();
exit(1);
}
s = NULL;
break;
default:
ILLEGAL_OPTION_HOOK;
fprintf(stderr, "%s: error: illegal option '%c'\n", progname, c);
show_help();
exit(1);
}
}
}
open_log_file(log_name);
if (ind < argc) {
dest_url = argv[ind++];
if (!auto_redirect) {
fprintf(stderr, "Automatic redirect disabled: argument '%s' ignored\n", dest_url);
dest_url = NULL;
}
}
#endif
bcg = broadcast_group_alloc();
/* Default filters (use "-fi" to disable). */
filter_add_message_filter("o,E,Locator,peerHeartBeat");
filter_add_message_filter("o,E,Locator,peerAdded");
filter_add_message_filter("o,E,Locator,peerRemoved");
filter_add_message_filter("o,E,Locator,peerChanged");
filter_add_message_filter("o,C,Locator,getPeers");
filter_add_message_filter("tr10,C,FileSystem,read");
filter_add_message_filter("t10,C,FileSystem,write");
set_proxy_log_filter_listener2(filter_is_log_filtered);
ps = channel_peer_from_url(url);
if (ps == NULL) {
fprintf(stderr, "%s: invalid server URL (-s option value): %s\n", progname, url);
exit(1);
}
peer_server_addprop(ps, loc_strdup("Name"), loc_strdup("TCF Protocol Logger"));
peer_server_addprop(ps, loc_strdup("Proxy"), loc_strdup(""));
SERVER_ADDPROP_HOOK;
serv = channel_server(ps);
if (serv == NULL) {
fprintf(stderr, "%s: cannot create TCF server: %s\n", progname, errno_to_str(errno));
exit(1);
}
serv->new_conn = channel_new_connection;
discovery_start();
if (print_server_properties) {
ChannelServer * s;
char * server_properties;
assert(!list_is_empty(&channel_server_root));
s = servlink2channelserverp(channel_server_root.next);
server_properties = channel_peer_to_json(s->ps);
printf("Server-Properties: %s\n", server_properties);
fflush(stdout);
trace(LOG_ALWAYS, "Server-Properties: %s", server_properties);
loc_free(server_properties);
}
/* Process events - must run on the initial thread since ptrace()
* returns ECHILD otherwise, thinking we are not the owner. */
run_event_loop();
return 0;
}
ChannelServer * channel_np_server(PeerServer * ps) {
/* const char * host = peer_server_getprop(ps, "Host", NULL);*/
const char * port = peer_server_getprop(ps, "Port", NULL);
char port_str[16];
const char * host = peer_server_getprop(ps, "Host", NULL);
const char * certificate = peer_server_getprop(ps, "CertificateFile", NULL);
const char * key = peer_server_getprop(ps, "KeyFile", NULL);
noPollCtx * np_ctx;
noPollConn * np_listener;
int ssl;
assert(is_dispatch_thread());
if (port == NULL) {
sprintf(port_str, "%d", DISCOVERY_TCF_PORT);
port = port_str;
}
ini_nopoll();
/* create the nopoll ctx */
np_ctx = nopoll_ctx_new ();
if(np_ctx == NULL) {
trace(LOG_ALWAYS, "Unable to create nopoll context: %s", errno_to_str(errno));
return NULL;
}
/*nopoll_log_enable(np_ctx, nopoll_true);*/
ssl = strcmp(peer_server_getprop(ps, "TransportName", ""), "WSS") == 0;
if (ssl) np_listener = nopoll_listener_tls_new (np_ctx, host == NULL ? "0.0.0.0" : host, port);
else np_listener = nopoll_listener_new (np_ctx, host == NULL ? "0.0.0.0" : host, port);
if (np_listener == NULL) {
trace(LOG_ALWAYS, "Unable to create nopoll listener: %s", errno_to_str(errno));
nopoll_ctx_unref(np_ctx);
return NULL;
}
/* configure certificates to be used by this listener */
if (ssl) {
errno = 0;
if (! nopoll_listener_set_certificate (np_listener, certificate, key, NULL)) {
printf ("ERROR: unable to configure certificates for TLS websocket..\n");
if (errno == 0) errno = EINVAL;
nopoll_conn_close (np_listener);
nopoll_ctx_unref(np_ctx);
return NULL;
}
/* register certificates at context level */
errno = 0;
if (! nopoll_ctx_set_certificate (np_ctx, NULL, certificate, key, NULL)) {
printf ("ERROR: unable to setup certificates at context level..\n");
if (errno == 0) errno = EINVAL;
nopoll_conn_close (np_listener);
nopoll_ctx_unref(np_ctx);
return NULL;
}
}
peer_server_addprop(ps, loc_strdup("Port"), loc_strdup(port));
return channel_server_create(ps, np_ctx, np_listener, ssl);
}
void channel_np_connect(PeerServer * ps, ChannelConnectCallBack callback, void * callback_args) {
const char * host = peer_server_getprop(ps, "Host", NULL);
const char * port = peer_server_getprop(ps, "Port", NULL);
const char * get_url = peer_server_getprop(ps, "GetUrl", NULL);
const char * host_name = peer_server_getprop(ps, "HostName", NULL);
#if ENABLE_WebSocket_SOCKS_V5
const char * proxy = peer_server_getprop(ps, "Proxy", NULL);
#endif
ChannelConnectInfo * info = NULL;
char port_str[16];
struct addrinfo hints;
struct addrinfo * reslist = NULL;
int error;
ini_nopoll();
if (port == NULL) {
sprintf(port_str, "%d", DISCOVERY_TCF_PORT);
port = port_str;
}
memset(&hints, 0, sizeof hints);
hints.ai_family = PF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
error = loc_getaddrinfo(host, port, &hints, &reslist);
if (error) error = set_gai_errno(error);
if (!error) {
struct addrinfo * res;
info = (ChannelConnectInfo *)loc_alloc_zero(sizeof(ChannelConnectInfo));
for (res = reslist; res != NULL; res = res->ai_next) {
info->addr_len = res->ai_addrlen;
info->addr_buf = (struct sockaddr *)loc_alloc(res->ai_addrlen);
memcpy(info->addr_buf, res->ai_addr, res->ai_addrlen);
error = 0;
break;
}
loc_freeaddrinfo(reslist);
}
if (!error && info->addr_buf == NULL) error = ENOENT;
if (error) {
if (info != NULL) {
loc_free(info->addr_buf);
loc_free(info);
}
callback(callback_args, error, NULL);
} else {
noPollCtx * np_ctx_client;
np_ctx_client = nopoll_ctx_new();
/*nopoll_log_enable(np_ctx_client, nopoll_true);*/
#if ENABLE_WebSocket_SOCKS_V5
if (proxy != NULL) {
/* save global proxy values */
char * proxy_host = socks_v5_host;
char * proxy_port = socks_v5_port;
if (parse_socks_v5_proxy(proxy) != 0) {
socks_v5_host = proxy_host;
socks_v5_port = proxy_port;
if (info != NULL) {
loc_free(info->addr_buf);
loc_free(info);
}
callback(callback_args, errno, NULL);
return;
}
if (socks_v5_host != NULL) nopoll_conn_set_socks_v5_proxy(np_ctx_client, socks_v5_host, socks_v5_port);
/* Restore global proxy values */
socks_v5_host = proxy_host;
socks_v5_port = proxy_port;
}
#endif
info->callback = callback;
info->callback_args = callback_args;
info->is_ssl = strcmp(peer_server_getprop(ps, "TransportName", ""), "WSS") == 0;
info->req.client_data = info;
info->req.done = channel_np_connect_done;
info->req.type = AsyncReqUser;
info->req.u.user.func = np_wt_connect;
info->req.u.user.data = info;
info->host = loc_strdup(host == NULL ? "127.0.0.1" : host);
info->port = loc_strdup(port);
info->get_url = get_url;
info->host_name = host_name;
info->np_ctx = np_ctx_client;
async_req_post(&info->req);
}
}
static void refresh_peer_server(int sock, PeerServer * ps) {
unsigned i;
const char * transport = peer_server_getprop(ps, "TransportName", NULL);
assert(transport != NULL);
if (strcmp(transport, "UNIX") == 0) {
char str_id[64];
PeerServer * ps2 = peer_server_alloc();
ps2->flags = ps->flags | PS_FLAG_LOCAL | PS_FLAG_DISCOVERABLE;
for (i = 0; i < ps->ind; i++) {
peer_server_addprop(ps2, loc_strdup(ps->list[i].name), loc_strdup(ps->list[i].value));
}
snprintf(str_id, sizeof(str_id), "%s:%s", transport, peer_server_getprop(ps, "Host", ""));
for (i = 0; str_id[i]; i++) {
/* Character '/' is prohibited in a peer ID string */
if (str_id[i] == '/') str_id[i] = '|';
}
peer_server_addprop(ps2, loc_strdup("ID"), loc_strdup(str_id));
peer_server_add(ps2, PEER_DATA_RETENTION_PERIOD * 2);
}
else {
struct sockaddr_in sin;
#if defined(_WRS_KERNEL)
int sinlen;
#else
socklen_t sinlen;
#endif
const char *str_port = peer_server_getprop(ps, "Port", NULL);
int ifcind;
struct in_addr src_addr;
ip_ifc_info ifclist[MAX_IFC];
sinlen = sizeof sin;
if (getsockname(sock, (struct sockaddr *)&sin, &sinlen) != 0) {
trace(LOG_ALWAYS, "refresh_peer_server: getsockname error: %s", errno_to_str(errno));
return;
}
ifcind = build_ifclist(sock, MAX_IFC, ifclist);
while (ifcind-- > 0) {
char str_host[64];
char str_id[64];
PeerServer * ps2;
if (sin.sin_addr.s_addr != INADDR_ANY &&
(ifclist[ifcind].addr & ifclist[ifcind].mask) !=
(sin.sin_addr.s_addr & ifclist[ifcind].mask)) {
continue;
}
src_addr.s_addr = ifclist[ifcind].addr;
ps2 = peer_server_alloc();
ps2->flags = ps->flags | PS_FLAG_LOCAL | PS_FLAG_DISCOVERABLE;
for (i = 0; i < ps->ind; i++) {
peer_server_addprop(ps2, loc_strdup(ps->list[i].name), loc_strdup(ps->list[i].value));
}
inet_ntop(AF_INET, &src_addr, str_host, sizeof(str_host));
snprintf(str_id, sizeof(str_id), "%s:%s:%s", transport, str_host, str_port);
peer_server_addprop(ps2, loc_strdup("ID"), loc_strdup(str_id));
peer_server_addprop(ps2, loc_strdup("Host"), loc_strdup(str_host));
peer_server_addprop(ps2, loc_strdup("Port"), loc_strdup(str_port));
peer_server_add(ps2, PEER_DATA_RETENTION_PERIOD * 2);
}
}
}
static void call_client(Context * ctx, CompUnit * unit, LineNumbersState * state,
LineNumbersState * code_next, LineNumbersState * text_next,
ContextAddress state_addr, LineNumbersCallBack * client, void * args) {
CodeArea area;
FileInfo * file_info = unit->mFiles + state->mFile;
LineNumbersState * text_next_stmt = get_next_statement(unit, text_next);
if (code_next == NULL) return;
assert(state->mSection == code_next->mSection);
memset(&area, 0, sizeof(area));
area.start_line = state->mLine;
area.start_column = state->mColumn;
area.end_line = text_next ? text_next->mLine : state->mLine + 1;
area.end_column = text_next ? text_next->mColumn : 0;
area.directory = unit->mDir;
if (state->mFileName != NULL) {
area.file = state->mFileName;
}
else if (is_absolute_path(file_info->mName) || file_info->mDir == NULL) {
area.file = file_info->mName;
}
else if (is_absolute_path(file_info->mDir)) {
area.directory = file_info->mDir;
area.file = file_info->mName;
}
else {
char buf[FILE_PATH_SIZE];
snprintf(buf, sizeof(buf), "%s/%s", file_info->mDir, file_info->mName);
area.file = state->mFileName = loc_strdup(buf);
}
area.file_mtime = file_info->mModTime;
area.file_size = file_info->mSize;
area.start_address = state_addr;
area.end_address = code_next->mAddress - state->mAddress + state_addr;
if (text_next != NULL) {
if (text_next->mSection == state->mSection) {
area.next_address = text_next->mAddress - state->mAddress + state_addr;
}
else {
ELF_Section * s = NULL;
if (text_next->mSection) s = unit->mFile->sections + text_next->mSection;
area.next_address = elf_map_to_run_time_address(ctx, unit->mFile, s, text_next->mAddress);
}
}
if (text_next_stmt != NULL) {
if (text_next_stmt->mSection == state->mSection) {
area.next_stmt_address = text_next_stmt->mAddress - state->mAddress + state_addr;
}
else {
ELF_Section * s = NULL;
if (text_next_stmt->mSection) s = unit->mFile->sections + text_next_stmt->mSection;
area.next_stmt_address = elf_map_to_run_time_address(ctx, unit->mFile, s, text_next_stmt->mAddress);
}
}
area.isa = state->mISA;
area.is_statement = (state->mFlags & LINE_IsStmt) != 0;
area.basic_block = (state->mFlags & LINE_BasicBlock) != 0;
area.prologue_end = (state->mFlags & LINE_PrologueEnd) != 0;
area.epilogue_begin = (state->mFlags & LINE_EpilogueBegin) != 0;
area.op_index = state->mOpIndex;
area.discriminator = state->mDiscriminator;
client(&area, args);
}
int tcf_log(void) {
#else
int main(int argc, char ** argv) {
int c;
int ind;
const char * log_name = "-";
#endif
const char * url = "TCP:";
PeerServer * ps;
ChannelServer * serv;
ini_mdep();
ini_trace();
ini_events_queue();
ini_asyncreq();
log_mode = LOG_TCFLOG;
#if defined(_WRS_KERNEL)
progname = "tcf";
open_log_file("-");
#else
progname = argv[0];
/* Parse arguments */
for (ind = 1; ind < argc; ind++) {
const char * s = argv[ind];
if (*s != '-') {
break;
}
s++;
while ((c = *s++) != '\0') {
switch (c) {
case 'h':
show_help();
exit (0);
case 'l':
case 'L':
case 's':
if (*s == '\0') {
if (++ind >= argc) {
fprintf(stderr, "%s: error: no argument given to option '%c'\n", progname, c);
exit(1);
}
s = argv[ind];
}
switch (c) {
case 'l':
if (parse_trace_mode(s, &log_mode) != 0) {
fprintf(stderr, "Cannot parse log level: %s\n", s);
exit(1);
}
break;
case 'L':
log_name = s;
break;
case 's':
url = s;
break;
default:
fprintf(stderr, "%s: error: illegal option '%c'\n", progname, c);
show_help();
exit(1);
}
s = "";
break;
default:
fprintf(stderr, "%s: error: illegal option '%c'\n", progname, c);
show_help();
exit(1);
}
}
}
open_log_file(log_name);
if (ind < argc) {
dest_url = argv[ind++];
}
#endif
ps = channel_peer_from_url(url);
if (ps == NULL) {
fprintf(stderr, "%s: invalid server URL (-s option value): %s\n", progname, url);
exit(1);
}
peer_server_addprop(ps, loc_strdup("Name"), loc_strdup("TCF Protocol Logger"));
peer_server_addprop(ps, loc_strdup("Proxy"), loc_strdup(""));
serv = channel_server(ps);
if (serv == NULL) {
fprintf(stderr, "%s: cannot create TCF server: %s\n", progname, errno_to_str(errno));
exit(1);
}
serv->new_conn = channel_new_connection;
discovery_start();
/* Process events - must run on the initial thread since ptrace()
* returns ECHILD otherwise, thinking we are not the owner. */
run_event_loop();
return 0;
}
