void get_cmdline_by_pid(struct procinfo *pi)
{
char cmd_path[128];
char cmd[256];
char resolved[256];
FILE *fp;
memset(cmd_path, 0, 128);
memset(cmd, 0, 256);
sprintf(cmd_path, "/proc/%d/cmdline", pi->pi_pid);
fp = fopen(cmd_path, "r");
fgets(cmd, 256, fp);
/*resolve all symlinks */
check_target_path((u_char *) cmd, pi->pi_perm);
memset(cmd, 0, 256);
memcpy(cmd, pi->pi_perm->p_full_path,
strlen((const char *)pi->pi_perm->p_full_path));
strcpy((char *)pi->pi_perm->p_full_path, realpath(cmd, resolved));
#if 0
printfd(2, DEBUG "cmdline path : %s\n", cmd_path);
printfd(2, DEBUG "cmd is : %s\n", pi->pi_perm->p_full_path);
#endif
}
int
sys_epoll_ctl(struct tcb *tcp)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printxval(epollctls, tcp->u_arg[1], "EPOLL_CTL_???");
tprints(", ");
printfd(tcp, tcp->u_arg[2]);
tprints(", ");
if (tcp->u_arg[3] == 0)
tprints("NULL");
else {
#ifdef HAVE_SYS_EPOLL_H
struct epoll_event ev;
if (
#ifdef EPOLL_CTL_DEL
(tcp->u_arg[1] != EPOLL_CTL_DEL) &&
#endif
umove(tcp, tcp->u_arg[3], &ev) == 0)
print_epoll_event(&ev);
else
#endif
tprintf("%lx", tcp->u_arg[3]);
}
}
return 0;
}
int
sys_sendfile(struct tcb *tcp)
{
if (entering(tcp)) {
off_t offset;
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printfd(tcp, tcp->u_arg[1]);
tprints(", ");
if (!tcp->u_arg[2])
tprints("NULL");
//FIXME: obviously bogus.
//Probably should use explicit long.
//Arches with long long offset param should use
//sys_sendfile64, not this fn.
else if (umove(tcp, tcp->u_arg[2], &offset) < 0)
tprintf("%#lx", tcp->u_arg[2]);
else
#ifdef HAVE_LONG_LONG_OFF_T
tprintf("[%llu]", offset);
#else
tprintf("[%lu]", offset);
#endif
tprintf(", %lu", tcp->u_arg[3]);
}
return 0;
}
static void
printpair_fd(struct tcb *tcp, const int i0, const int i1)
{
tprints("[");
printfd(tcp, i0);
tprints(", ");
printfd(tcp, i1);
tprints("]");
}
//-----------------------------------------------------------------------------
void USER_IMPL::Run()
{
STG_LOCKER lock(&mutex);
if (stgTime > static_cast<time_t>(lastWriteStat + settings->GetStatWritePeriod()))
{
printfd(__FILE__, "USER::WriteStat user=%s\n", GetLogin().c_str());
WriteStat();
}
if (creditExpire.ConstData() && creditExpire.ConstData() < stgTime)
{
WriteServLog("User: %s. Credit expired.", login.c_str());
credit = 0;
creditExpire = 0;
WriteConf();
}
if (passive.ConstData()
&& (stgTime % 30 == 0)
&& (passiveTime.ModificationTime() != stgTime))
{
passiveTime = passiveTime + (stgTime - passiveTime.ModificationTime());
printfd(__FILE__, "===== %s: passiveTime=%d =====\n", login.c_str(), passiveTime.ConstData());
}
if (!authorizedBy.empty())
{
if (connected)
property.Stat().lastActivityTime = stgTime;
if (!connected && IsInetable())
Connect();
if (connected && !IsInetable())
{
if (disabled)
Disconnect(false, "disabled");
else if (passive)
Disconnect(false, "passive");
else
Disconnect(false, "no cash");
}
if (stgTime - lastScanMessages > 10)
{
ScanMessage();
lastScanMessages = stgTime;
}
}
else
{
if (connected)
Disconnect(false, "not authorized");
}
}
//-----------------------------------------------------------------------------
void USER_IMPL::ScanMessage()
{
// No lock `cause we are already locked from caller
// We need not check for the authorizedBy `cause it has already checked by caller
std::list<STG_MSG>::iterator it(messages.begin());
while (it != messages.end())
{
if (settings->GetMessageTimeout() > 0 &&
difftime(stgTime, it->header.creationTime) > settings->GetMessageTimeout())
{
// Timeout exceeded
if (store->DelMessage(it->header.id, login))
{
WriteServLog("Error deleting message: '%s'", store->GetStrError().c_str());
printfd(__FILE__, "Error deleting message: '%s'\n", store->GetStrError().c_str());
}
messages.erase(it++);
continue;
}
if (it->GetNextSendTime() <= stgTime)
{
if (SendMessage(*it))
{
// We need to check all messages in queue for timeout
++it;
continue;
}
if (it->header.repeat < 0)
{
if (store->DelMessage(it->header.id, login))
{
WriteServLog("Error deleting message: '%s'", store->GetStrError().c_str());
printfd(__FILE__, "Error deleting message: '%s'\n", store->GetStrError().c_str());
}
messages.erase(it++);
}
else
{
if (store->EditMessage(*it, login))
{
WriteServLog("Error modifying message: '%s'", store->GetStrError().c_str());
printfd(__FILE__, "Error modifying message: '%s'\n", store->GetStrError().c_str());
}
++it;
}
}
else
{
++it;
}
}
}
static int
do_dup2(struct tcb *tcp, int flags_arg)
{
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printfd(tcp, tcp->u_arg[1]);
if (flags_arg >= 0) {
tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
return RVAL_DECODED | RVAL_FD;
}
int
sys_sendfile64(struct tcb *tcp)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printfd(tcp, tcp->u_arg[1]);
tprints(", ");
print_loff_t(tcp, tcp->u_arg[2]);
tprintf(", %lu", tcp->u_arg[3]);
}
return 0;
}
static int
do_dup2(struct tcb *tcp, int flags_arg)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printfd(tcp, tcp->u_arg[1]);
if (flags_arg >= 0) {
tprints(", ");
printflags(open_mode_flags, tcp->u_arg[flags_arg], "O_???");
}
}
return 0;
}
static int
print_mmap(struct tcb *tcp, long *u_arg, unsigned long long offset)
{
if (entering(tcp)) {
/* addr */
if (!u_arg[0])
tprints("NULL, ");
else
tprintf("%#lx, ", u_arg[0]);
/* len */
tprintf("%lu, ", u_arg[1]);
/* prot */
printflags(mmap_prot, u_arg[2], "PROT_???");
tprints(", ");
/* flags */
#ifdef MAP_TYPE
printxval(mmap_flags, u_arg[3] & MAP_TYPE, "MAP_???");
addflags(mmap_flags, u_arg[3] & ~MAP_TYPE);
#else
printflags(mmap_flags, u_arg[3], "MAP_???");
#endif
tprints(", ");
/* fd */
printfd(tcp, u_arg[4]);
/* offset */
tprintf(", %#llx", offset);
}
return RVAL_HEX;
}
static int
decode_sockname(struct tcb *tcp)
{
int ulen, rlen;
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
if (fetch_socklen(tcp, &ulen, tcp->u_arg[1], tcp->u_arg[2])) {
set_tcb_priv_ulong(tcp, ulen);
return 0;
} else {
printaddr(tcp->u_arg[1]);
tprints(", ");
printaddr(tcp->u_arg[2]);
return RVAL_DECODED;
}
}
ulen = get_tcb_priv_ulong(tcp);
if (syserror(tcp) || umove(tcp, tcp->u_arg[2], &rlen) < 0) {
printaddr(tcp->u_arg[1]);
tprintf(", [%d]", ulen);
} else {
decode_sockaddr(tcp, tcp->u_arg[1], ulen > rlen ? rlen : ulen);
if (ulen != rlen)
tprintf(", [%d->%d]", ulen, rlen);
else
tprintf(", [%d]", rlen);
}
return RVAL_DECODED;
}
static int
do_accept(struct tcb *tcp, int flags_arg)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
return 0;
}
if (!tcp->u_arg[2])
tprintf("%#lx, NULL", tcp->u_arg[1]);
else {
int len;
if (tcp->u_arg[1] == 0 || syserror(tcp)
|| umove(tcp, tcp->u_arg[2], &len) < 0) {
tprintf("%#lx", tcp->u_arg[1]);
} else {
printsock(tcp, tcp->u_arg[1], len);
}
tprints(", ");
printnum_int(tcp, tcp->u_arg[2], "%u");
}
if (flags_arg >= 0) {
tprints(", ");
printflags(sock_type_flags, tcp->u_arg[flags_arg],
"SOCK_???");
}
return 0;
}
// forced == 1
static void socksserver_disconnect_client(socksserver* srv, int fd, int forced) {
fdinfo* client = &srv->clients[fdindex(fd)];
int fdflag = 0;
if(CONFIG_LOG && srv->log) {
logstart();
printfd(fd);
LOGPUT(1, VARISL(" disconnect, forced: "), VARII(forced), NULL);
}
if(forced) rocksockserver_disconnect_client(&srv->serva, fd);
client->state = SS_DISCONNECTED;
if(client->data) {
client->data->state = BS_UNUSED;
client->data->start = 0;
client->data->used = 0;
}
if(client->target_fd != -1) fdflag = 1;
fd = client->target_fd;
client->target_fd = -1;
if(fdflag) {
srv->clients[fdindex(fd)].target_fd = -1;
socksserver_disconnect_client(srv, fd, 1);
}
}
int
sys_read(struct tcb *tcp)
{
struct socket_info sockinfo;
if (entering(tcp)) {
json_object_object_add(tcp->json, "fd", json_object_new_int((int)tcp->u_arg[0]));
printfd(tcp, tcp->u_arg[0]);
tprintf(", ");
if (output_json) {
if (get_socket_info(tcp->pid, (int) tcp->u_arg[0], &sockinfo) == 0) {
append_to_json(tcp->json, &sockinfo);
} else {
json_object_object_add(tcp->json, "pid", json_object_new_int(tcp->pid));
}
}
} else {
/* exiting... */
if (syserror(tcp)) {
tprintf("%#lx", tcp->u_arg[1]);
} else {
/* no error */
if (output_json) {
json_object_object_add(tcp->json, "content",
json_object_new_string(readstr(tcp, tcp->u_arg[1], tcp->u_arg[2])));
json_object_object_add(tcp->json, "length", json_object_new_int(tcp->u_arg[2]));
} else {
printstr(tcp, tcp->u_arg[1], tcp->u_rval);
}
}
tprintf(", %lu", tcp->u_arg[2]);
}
return 0;
}
static struct ia_circles *_core_mutate(struct ia_circles *circles, int idx)
{
struct ia_circles *mutated_circles = clone_circles(circles);
int max_tries = 0;
//const int ult_max_tries = circles->num_circles * 2;
const int ult_max_tries = 30;
while(max_tries < ult_max_tries) {
printfd("Mutating circle %d/%d\n",
idx,
circles->num_circles);
struct ia_circles *circles_prev = clone_circles(mutated_circles);
_ia_random_action(&mutated_circles->circles[idx], true);
refresh_circles(mutated_circles);
refresh_circles(circles_prev);
struct img_bitmap *_img = mutated_circles->img;
struct img_bitmap *_img_prev = circles_prev->img;
if((_img->score - _img_prev->score) > 0) {
max_tries++;
memcpy(&mutated_circles->circles[idx],
&circles_prev->circles[idx],
sizeof(struct ia_circle));
refresh_circles(mutated_circles);
} else {
max_tries = ult_max_tries;
}
free_circles(circles_prev);
free(circles_prev);
}
refresh_circles(mutated_circles);
return mutated_circles;
}
int
sys_ioctl(struct tcb *tcp)
{
const struct_ioctlent *iop;
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
iop = ioctl_lookup(tcp->u_arg[1]);
if (iop) {
tprints(iop->symbol);
while ((iop = ioctl_next_match(iop)))
tprintf(" or %s", iop->symbol);
} else
tprintf("%#lx", tcp->u_arg[1]);
ioctl_decode(tcp, tcp->u_arg[1], tcp->u_arg[2]);
}
else {
int ret = ioctl_decode(tcp, tcp->u_arg[1], tcp->u_arg[2]);
if (!ret)
tprintf(", %#lx", tcp->u_arg[2]);
else
return ret - 1;
}
return 0;
}
int
nbd_ioctl(struct tcb *const tcp, const unsigned int code,
const kernel_ulong_t arg)
{
switch (code) {
case NBD_DISCONNECT:
case NBD_CLEAR_SOCK:
case NBD_DO_IT:
case NBD_CLEAR_QUE:
case NBD_PRINT_DEBUG:
return RVAL_IOCTL_DECODED;
case NBD_SET_SOCK:
tprints(", ");
printfd(tcp, arg);
return RVAL_IOCTL_DECODED;
case NBD_SET_BLKSIZE:
case NBD_SET_SIZE:
case NBD_SET_SIZE_BLOCKS:
case NBD_SET_TIMEOUT:
tprints(", ");
tprintf("%" PRI_klu, arg);
return RVAL_IOCTL_DECODED;
case NBD_SET_FLAGS:
tprints(", ");
printflags(nbd_ioctl_flags, arg, "NBD_IOC_FLAG_???");
return RVAL_IOCTL_DECODED;
default:
return RVAL_DECODED;
}
}
int
sys_fanotify_mark(struct tcb *tcp)
{
unsigned long long mask = 0;
int argn;
if (exiting(tcp))
return 0;
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
printflags(fan_mark_flags, (unsigned) tcp->u_arg[1], "FAN_MARK_???");
tprints(", ");
/*
* the mask argument is defined as 64-bit,
* but kernel uses the lower 32 bits only.
*/
argn = getllval(tcp, &mask, 2);
printflags(fan_event_flags, mask, "FAN_???");
tprints(", ");
if ((int) tcp->u_arg[argn] == FAN_NOFD)
tprints("FAN_NOFD, ");
else
print_dirfd(tcp, tcp->u_arg[argn]);
printpath(tcp, tcp->u_arg[argn + 1]);
return 0;
}
static bool
print_file_dedupe_range_info(struct tcb *tcp, void *elem_buf,
size_t elem_size, void *data)
{
const struct file_dedupe_range_info *info = elem_buf;
unsigned int *count = data;
if (count) {
if (*count == 0) {
tprints("...");
return false;
}
--*count;
}
if (entering(tcp)) {
tprints("{dest_fd=");
printfd(tcp, info->dest_fd);
tprintf(", dest_offset=%" PRIu64 "}",
(uint64_t) info->dest_offset);
} else {
tprintf("{bytes_deduped=%" PRIu64 ", status=%d}",
(uint64_t) info->bytes_deduped, info->status);
}
return true;
}
static int
do_sockname(struct tcb *tcp, int flags_arg)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
return 0;
}
int len;
if (!tcp->u_arg[2] || !verbose(tcp) || syserror(tcp) ||
umove(tcp, tcp->u_arg[2], &len) < 0) {
printaddr(tcp->u_arg[1]);
tprints(", ");
printaddr(tcp->u_arg[2]);
} else {
printsock(tcp, tcp->u_arg[1], len);
tprintf(", [%d]", len);
}
if (flags_arg >= 0) {
tprints(", ");
printflags(sock_type_flags, tcp->u_arg[flags_arg],
"SOCK_???");
}
return 0;
}
//-----------------------------------------------------------------------------
int USER_IMPL::ReadConf()
{
STG_LOCKER lock(&mutex);
USER_CONF conf;
if (store->RestoreUserConf(&conf, login))
{
WriteServLog("Cannot read conf for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
printfd(__FILE__, "Cannot read conf for user %s.\n", login.c_str());
printfd(__FILE__, "%s\n", store->GetStrError().c_str());
return -1;
}
property.SetConf(conf);
tariff = tariffs->FindByName(tariffName);
if (tariff == NULL)
{
WriteServLog("Cannot read user %s. Tariff %s not exist.",
login.c_str(), property.tariffName.Get().c_str());
return -1;
}
std::vector<STG_MSG_HDR> hdrsList;
if (store->GetMessageHdrs(&hdrsList, login))
{
printfd(__FILE__, "Error GetMessageHdrs %s\n", store->GetStrError().c_str());
WriteServLog("Cannot read user %s. Error reading message headers: %s.",
login.c_str(),
store->GetStrError().c_str());
return -1;
}
std::vector<STG_MSG_HDR>::const_iterator it;
for (it = hdrsList.begin(); it != hdrsList.end(); ++it)
{
STG_MSG msg;
if (store->GetMessage(it->id, &msg, login) == 0)
{
messages.push_back(msg);
}
}
return 0;
}
//-----------------------------------------------------------------------------
void CHG_IPS_NOTIFIER::Notify(const USER_IPS & from, const USER_IPS & to)
{
printfd(__FILE__, "Change IP from '%s' to '%s'\n", from.GetIpStr().c_str(), to.GetIpStr().c_str());
if (user->connected)
user->Disconnect(false, "Change IP");
if (!user->authorizedBy.empty() && user->IsInetable())
user->Connect(false);
}
int
sys_tee(struct tcb *tcp)
{
if (entering(tcp)) {
/* int fd_in */
printfd(tcp, tcp->u_arg[0]);
tprints(", ");
/* int fd_out */
printfd(tcp, tcp->u_arg[1]);
tprints(", ");
/* size_t len */
tprintf("%lu, ", tcp->u_arg[2]);
/* unsigned int flags */
printflags(splice_flags, tcp->u_arg[3], "SPLICE_F_???");
}
return 0;
}
int
sys_close(struct tcb *tcp)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
}
return 0;
}
int
sys_dup(struct tcb *tcp)
{
if (entering(tcp)) {
printfd(tcp, tcp->u_arg[0]);
}
return RVAL_FD;
}
void banner(const char *arg)
{
printfd(1,"Usage : \n"
"%s <server IP> <server port> <locale IP> [MTU]\n"
,arg
);
exit(0);
}
//-----------------------------------------------------------------------------
int USER_IMPL::WriteDetailStat(bool hard)
{
printfd(__FILE__, "USER::WriteDetailedStat() - saved size = %d\n", traffStatSaved.second.size());
if (!traffStatSaved.second.empty())
{
if (store->WriteDetailedStat(traffStatSaved.second, traffStatSaved.first, login))
{
printfd(__FILE__, "USER::WriteDetailStat() - failed to write detail stat from queue\n");
WriteServLog("Cannot write detail stat from queue (of size %d recs) for user %s.", traffStatSaved.second.size(), login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
return -1;
}
traffStatSaved.second.erase(traffStatSaved.second.begin(), traffStatSaved.second.end());
}
TRAFF_STAT ts;
{
STG_LOCKER lock(&mutex);
ts.swap(traffStat);
}
printfd(__FILE__, "USER::WriteDetailedStat() - size = %d\n", ts.size());
if (ts.size() && !disabledDetailStat)
{
if (store->WriteDetailedStat(ts, lastWriteDetailedStat, login))
{
printfd(__FILE__, "USER::WriteDetailStat() - failed to write current detail stat\n");
WriteServLog("Cannot write detail stat for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
if (!hard)
{
printfd(__FILE__, "USER::WriteDetailStat() - pushing detail stat to queue\n");
STG_LOCKER lock(&mutex);
traffStatSaved.second.swap(ts);
traffStatSaved.first = lastWriteDetailedStat;
}
return -1;
}
}
lastWriteDetailedStat = stgTime;
return 0;
}
//-----------------------------------------------------------------------------
int USER_IMPL::WriteStat()
{
STG_LOCKER lock(&mutex);
USER_STAT stat(property.GetStat());
if (store->SaveUserStat(stat, login))
{
WriteServLog("Cannot write stat for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
printfd(__FILE__, "Cannot write stat for user %s.\n", login.c_str());
printfd(__FILE__, "%s\n", store->GetStrError().c_str());
return -1;
}
lastWriteStat = stgTime;
return 0;
}
//-----------------------------------------------------------------------------
int USER_IMPL::WriteConf()
{
STG_LOCKER lock(&mutex);
USER_CONF conf(property.GetConf());
printfd(__FILE__, "USER::WriteConf()\n");
if (store->SaveUserConf(conf, login))
{
WriteServLog("Cannot write conf for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
printfd(__FILE__, "Cannot write conf for user %s.\n", login.c_str());
printfd(__FILE__, "%s\n", store->GetStrError().c_str());
return -1;
}
return 0;
}
//-----------------------------------------------------------------------------
int USER_IMPL::ReadStat()
{
STG_LOCKER lock(&mutex);
USER_STAT stat;
if (store->RestoreUserStat(&stat, login))
{
WriteServLog("Cannot read stat for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
printfd(__FILE__, "Cannot read stat for user %s.\n", login.c_str());
printfd(__FILE__, "%s\n", store->GetStrError().c_str());
return -1;
}
property.SetStat(stat);
return 0;
}
