bool WINAPI DllMain(HMODULE hDll, DWORD dwReason, PVOID pvReserved)
{
if(dwReason == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls(hDll);
GetModuleFileName(hDll, dlldir, 512);
for(int i = strlen(dlldir); i > 0; i--) { if(dlldir[i] == '\\') { dlldir[i+1] = 0; break; } }
ofile.open(GetDirectoryFile("ttnlog.txt"), ios::app);
add_log("\n---------------------\nTatniumD3D Started...\n---------------------");
char sysd3d[320];
GetSystemDirectory(sysd3d, 320);
strcat(sysd3d, "\\d3d9.dll");
add_log("Library: %s", sysd3d);
HMODULE hMod = LoadLibrary(sysd3d);
oDirect3DCreate9 = (tDirect3DCreate9)GetProcAddress(hMod, "Direct3DCreate9");
return true;
}
else if(dwReason == DLL_PROCESS_DETACH)
{
add_log("---------------------\nTatniumD3D Exiting...\n---------------------\n");
if(ofile) { ofile.close(); }
}
return false;
}
static int receive_file(t_handle *handle, char *path, int size, t_msg *msg)
{
char *buf;
int fd;
if (!(buf = malloc(sizeof(char) * size)))
return (_error("Can't allocate memory : %m\n", -1));
if ((fd = open(path, O_RDWR)) < 0)
return (_warning("Can't open file : %m\n", -1));
if (read(fd, buf, size) < 0)
return (_warning("Can't read file : %m\n", -1));
if (write(handle->cli_fd, buf, size) < 0)
return (_error("Can't write on client %d: %m\n", -1, handle->cli_num));
if (server_read_sock(handle, buf) < 0)
return (IWARNING);
if (!strncmp(buf, "OK", 2))
add_log("File %s successfully send to client %d\n", 0, msg->arg
, handle->cli_num);
else
add_log("Fail to send file %s to client %d\n", 0, msg->arg
, handle->cli_num);
free(buf);
close(fd);
return (ISUCCESS);
}
/*
* parse qfq options
*/
int parse_tca_options_qfq(char *msg, char **mp, struct rtattr *tca)
{
struct rtattr *qfq[__TCA_QFQ_MAX];
parse_nested_rtattr(qfq, TCA_QFQ_MAX, tca);
if(qfq[TCA_QFQ_WEIGHT]) {
if(RTA_PAYLOAD(qfq[TCA_QFQ_WEIGHT]) < sizeof(unsigned)) {
rec_log("error: %s: TCA_QFQ_WEIGHT: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "weight=%u ",
*(unsigned *)RTA_DATA(qfq[TCA_QFQ_WEIGHT]));
}
if(qfq[TCA_QFQ_LMAX]) {
if(RTA_PAYLOAD(qfq[TCA_QFQ_MAX]) < sizeof(unsigned)) {
rec_log("error: %s: TCA_QFQ_WEIGHT: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "maxpkt=%u(byte) ",
*(unsigned *)RTA_DATA(qfq[TCA_QFQ_LMAX]));
}
return(0);
}
/*
* parse attribute TCA_RSVP_PINFO
*/
int parse_tca_rsvp_pinfo(char *msg, char **mp, struct rtattr *rsvp)
{
struct tc_rsvp_pinfo *pinfo;
struct tc_rsvp_gpi *dpi, *spi;
struct protoent *proto;
if(RTA_PAYLOAD(rsvp) < sizeof(*pinfo)) {
rec_log("error: %s: -- payload too short --", __func__);
return(1);
}
pinfo = (struct tc_rsvp_pinfo *)RTA_DATA(rsvp);
dpi = &(pinfo->dpi);
spi = &(pinfo->spi);
proto = getprotobynumber(pinfo->protocol);
*mp = add_log(msg, *mp, "dpi(key/mask/offset)=0x%08x/0x%08x/%d ",
htonl(dpi->key), htonl(dpi->mask), dpi->offset);
*mp = add_log(msg, *mp, "spi(key/mask/offset)=0x%08x/0x%08x/%d ",
htonl(spi->key), htonl(spi->mask), spi->offset);
*mp = add_log(msg, *mp, "tunnel(protocol/id/hdr)=%d(%s)/%d/%d ",
pinfo->protocol, proto ? proto->p_name : "unknown",
pinfo->tunnelid, pinfo->tunnelhdr);
return(0);
}
void Submit::handshake()
{
//emit add_log(LOG_INFO, "Submit::handshake");
QString time_str = QString::number(QDateTime::currentDateTime().toTime_t());
QCryptographicHash auth_hash(QCryptographicHash::Md5);
auth_hash.addData(QString(context.password_hash + time_str).toLocal8Bit());
QString auth = QString(auth_hash.result().toHex());
QUrl url_handshake = QString( "http://%1/?hs=true&p=%2&c=%3&v=%4&u=%5&t=%6&a=%7" )
.arg(context.host, PROTOCOL_VERSION, CLIENT_ID, CLIENT_VERSION )
.arg( QString(QUrl::toPercentEncoding(context.username) ))
.arg( time_str, auth );
emit add_log(LOG_DEBUG, QString("%1: Time: %2")
.arg(SITE_NAME[index], time_str));
emit add_log(LOG_DEBUG, QString("%1: Auth: %2")
.arg(SITE_NAME[index], auth));
emit add_log(LOG_DEBUG, QString("%1: URL: %2")
.arg(SITE_NAME[index], url_handshake.toString(QUrl::None)));
QNetworkRequest request_handshake;
request_handshake.setUrl(url_handshake);
request_handshake.setRawHeader("User-Agent", CLIENT_USERAGENT);
nr_handshake = nam_handshake->get(request_handshake);
}
rt_public EIF_BOOLEAN recv_ack (void)
{
Request pack;
Request_Clean (pack);
#ifdef EIF_WINDOWS
if (-1 == ewb_recv_packet(ewb_sp, &pack, TRUE))
#else
if (-1 == ewb_recv_packet(ewb_sp, &pack))
#endif
return (EIF_BOOLEAN) 0;
#ifdef USE_ADD_LOG
add_log(100, "receiving request : %ld for ec", pack.rq_type);
#endif
switch (pack.rq_type) {
case ACKNLGE:
#ifdef USE_ADD_LOG
add_log(100, "acknowledge request : %ld for ec", pack.rq_ack.ak_type);
#endif
switch (pack.rq_ack.ak_type) {
case AK_OK:
return (EIF_BOOLEAN) 1;
case AK_ERROR:
return (EIF_BOOLEAN) 0;
default:
return (EIF_BOOLEAN) 0;
}
default:
return (EIF_BOOLEAN) 0;
}
}
void Parse_MTP::mtp_do_storage(bool clear)
{
IPortableDevice *pd;
IPortableDeviceValues *pdv;
IPortableDeviceContent *pdc = NULL;
HRESULT hr;
hr = CoCreateInstance(CLSID_PortableDevice, NULL, CLSCTX_INPROC_SERVER,
IID_IPortableDevice, (VOID**)&pd);
if (FAILED(hr))
{
emit add_log(LOG_ERROR, QString("mtp_do_storage: Failed to create IPortableDevice: %1")
.arg(hr, 0, 16));
return;
}
hr = CoCreateInstance(CLSID_PortableDeviceValues, NULL, CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues, (VOID**)&pdv);
if (FAILED(hr))
{
emit add_log(LOG_ERROR, QString("mtp_do_storage: Failed to create IPortableDeviceValues: %1")
.arg(hr, 0, 16));
return;
}
for (int i = 0; i < mtp_devices.size(); i++)
{
// after this we're creating objects which need to be cleaned up.
hr = pd->Open(mtp_devices[i], pdv);
if (FAILED(hr))
{
emit add_log(LOG_ERROR, QString("mtp_do_storage: Failed to open IPortableDevice: %1")
.arg(hr, 0, 16));
goto mtp_do_storage_cleanup;
}
hr = pd->Content(&pdc);
if (FAILED(hr))
{
emit add_log(LOG_ERROR, QString("mtp_do_storage: Failed to retrieve content from IPortableDevice: %1")
.arg(hr, 0, 16));
goto mtp_do_storage_cleanup;
}
mtp_recurse_storage(WPD_DEVICE_OBJECT_ID, pdc, clear);
mtp_do_storage_cleanup:
if (pdc)
{
pdc->Release();
pdc = NULL;
}
if (pdv)
{
pdv->Release();
pdv = NULL;
}
pd->Close();
}
}
int do_init(int argc, char **argv) {
int i;
char *CONF_FILE = "conf/login.conf";
char *LANG_FILE = "conf/lang.conf";
char *INTER_FILE = "conf/inter.conf";
srand(gettick());
set_logfile("log/login.log");
set_dmpfile("log/login_dump.log");
for (i = 1; i < argc ; i++) {
if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "--h") == 0 || strcmp(argv[i], "--?") == 0 || strcmp(argv[i], "/?") == 0)
help_screen();
else if (strcmp(argv[i], "--conf") == 0)
CONF_FILE=argv[i+1];
else if (strcmp(argv[i],"--inter") == 0)
INTER_FILE = argv[i+1];
else if (strcmp(argv[i],"--lang") == 0)
LANG_FILE = argv[i+1];
}
config_read(CONF_FILE);
config_read(INTER_FILE);
config_read("conf/char.conf");
sql_handle = Sql_Malloc();
if(sql_handle==NULL)
{
Sql_ShowDebug(sql_handle);
exit(EXIT_FAILURE);
}
if( SQL_ERROR == Sql_Connect(sql_handle, sql_id, sql_pw, sql_ip, (uint16)sql_port, sql_db) )
{
printf("id: %s pass: %s Port: %d\n",sql_id, sql_pw,sql_port);
Sql_ShowDebug(sql_handle);
Sql_Free(sql_handle);
exit(EXIT_FAILURE);
}
//sql_init();
lang_read(LANG_FILE);
set_termfunc(do_term);
//zlib_init();
add_log("");
add_log("mYnexia Login Server Started.\n");
set_defaultaccept(clif_accept);
set_defaultparse(clif_parse);
login_fd = make_listen_port(login_port);
timer_insert(10 * 60 * 1000, 10 * 60 * 1000, Remove_Throttle, 0, 0);
//Lockout DB
bf_lockout=uidb_alloc(DB_OPT_BASE);
printf("mYnexia Login Server is \033[1;32mready\033[0m! Listening at %d.\n", login_port);
add_log("Server Ready! Listening at %d.\n", login_port);
return 0;
}
/*
* parse attributes TCA_ACT_*
*/
int parse_tca_act(char *msg, char *mp, struct rtattr *acts)
{
struct rtattr *act[__TCA_ACT_MAX];
char kind[IFNAMSIZ] = "";
mp = add_log(msg, mp, "order=%d ", acts->rta_type);
parse_nested_rtattr(act, __TCA_ACT_MAX-1, acts);
if(act[TCA_ACT_KIND]) {
strncpy(kind, (char *)RTA_DATA(act[TCA_ACT_KIND]), sizeof(kind));
mp = add_log(msg, mp, "action=%s ", kind);
}
if(act[TCA_ACT_OPTIONS]) {
if(!strncmp(kind, "police", sizeof(kind))) {
if(parse_tca_act_options_police(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
} else if(!strncmp(kind, "gact", sizeof(kind))) {
if(parse_tca_act_options_gact(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
} else if(!strncmp(kind, "pedit", sizeof(kind))) {
if(parse_tca_act_options_pedit(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
} else if(!strncmp(kind, "mirred", sizeof(kind))) {
if(parse_tca_act_options_mirred(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
#ifdef HAVE_LINUX_TC_ACT_TC_NAT_H
} else if(!strncmp(kind, "nat", sizeof(kind))) {
if(parse_tca_act_options_nat(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
#endif
#ifdef HAVE_LINUX_TC_ACT_TC_SKBEDIT_H
} else if(!strncmp(kind, "skbedit", sizeof(kind))) {
if(parse_tca_act_options_skbedit(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
#endif
#ifdef HAVE_LINUX_TC_ACT_TC_CSUM_H
} else if(!strncmp(kind, "csum", sizeof(kind))) {
if(parse_tca_act_options_csum(msg, mp, act[TCA_ACT_OPTIONS]))
return(1);
return(0);
#endif
}
}
rec_log("%s", msg);
return(0);
}
int pantech_logfile_save_log( const char* msg )
{
fs_handle_type file;
file = open_log_file();
if( file == FS_NULL_HANDLE )
{
return -1;
}
if( g_head.count_ < MAX_LOG )
{
IDX_T new_idx;
new_idx = add_log( file, &g_head, msg );
if( new_idx == NULL_IDX ) return FALSE;
if( set_value( file, LOG_COUNT_POS, g_head.count_, 4 ) == FALSE ) return FALSE;
if( set_value( file, TAIL_POS, g_head.tail_, 4 ) == FALSE ) return FALSE;
if( set_value( file, FREE_HEAD_POS, g_head.free_head_, 4 ) == FALSE ) return FALSE;
if( set_prev_next( file, &g_head, new_idx ) == FALSE ) return FALSE;
if( g_head.count_ == 1 )
{
if( set_value( file, HEAD_POS, g_head.head_, 4 ) == FALSE ) return FALSE;
}
else
{
if( set_prev_next( file, &g_head, g_head.prev_[ new_idx ] ) == FALSE ) return FALSE;
}
}
else
{
IDX_T idx;
idx = g_head.head_;
g_head.head_ = g_head.next_[ idx ];
g_head.free_head_ = idx;
g_head.next_[ idx ] = NULL_IDX;
g_head.count_--;
if( add_log( file, &g_head, msg ) != idx ) return FALSE;
if( set_value( file, HEAD_POS, g_head.head_, 4 ) == FALSE ) return FALSE;
if( set_value( file, TAIL_POS, g_head.tail_, 4 ) == FALSE ) return FALSE;
if( set_prev_next( file, &g_head, idx ) == FALSE ) return FALSE;
if( set_prev_next( file, &g_head, g_head.prev_[ idx ] ) == FALSE ) return FALSE;
}
pantech_fclose( file );
return 0;
}
// MAIN ENTRY
BOOL __stdcall DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
{
(void)lpvReserved;
(void)hinstDll;
//Read the config file
g_reader = new configReader;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls(hOriginalDll);
// Splash Screen enabled?
if (g_reader->GetEnableSplashScreen())
{
char info[255];
sprintf_s(info, "OpenGL3DVision Wrapper v.%s", OGL3DVISION_VERSION_STR);
// SDK Message box
CustomMessageBox(NULL, _T(" \t\t\t\t\t\t \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"),
_T(info), MB_OK);
}
// Init the wrapper
LoadFPSInject();
Init();
break;
case DLL_PROCESS_DETACH:
if (hOriginalDll != NULL)
{
// Stop the threads
StopResizeThread();
StoptNVAPIThread();
Sleep(500);
NV3DVisionBuffers_destroy(gl_d3d_buffers);
add_log("\nDisabling 3D Vision... Cleaning up and freeing the resources...");
// Removing the FPS inject
if (FPSDestroy)
{
(FPSDestroy)(m_FPSInjector);
}
FreeLibrary(FPSHandle);
add_log("Application closed successfully !\nEND\n");
// The the openGL32.dll lib
FreeLibrary(hOriginalDll);
hOriginalDll = NULL;
}
break;
}
return TRUE;
}
IDirect3D9 *APIENTRY hkDirect3DCreate9(UINT SDKVersion)
{
IDirect3D9 *d3dint = oDirect3DCreate9(SDKVersion);
if( d3dint != NULL )
{
hkIDirect3D9 *ret = new hkIDirect3D9(&d3dint);
add_log("Direct3DCreate9(%i) succeeded...", SDKVersion);
add_log("Hooked Direct3D9 interface: 0x%x -> 0x%x", ret->m_pD3Dint, ret);
}
else
add_log("Direct3DCreate9(%i) failed...", SDKVersion);
return d3dint;
}
rt_public int app_start(char *cmd)
/* The command string (without i/o redirection) */
{
/* Start application under ised control and establish communication link
* with ewb for debugging purpose. Return 0 if ok, -1 for failure.
*/
Request rqst;
Request_Clean (rqst);
rqst.rq_type = APPLICATION; /* Request application start-up */
ewb_send_packet(ewb_sp, &rqst); /* Send request for ised processing */
if (-1 == send_str(ewb_sp, cmd)) { /* Send command string */
#ifdef USE_ADD_LOG
add_log(2, "ERROR cannot send command string");
#endif
return -1;
}
#ifdef EIF_WINDOWS
ewb_recv_packet(ewb_sp, &rqst, TRUE); /* Acknowledgment */
#else
ewb_recv_packet(ewb_sp, &rqst); /* Acknowledgment */
#endif
return AK_OK == rqst.rq_ack.ak_type ? 0 : -1;
}
static turn_command_t process_input_log(game_t * game, int input)
{
int log_input_index = strlen(game->log.log_input) - 1;
if(input == KEY_BACKSPACE) {
if(log_input_index < 0) {
return turn_command_void;
}
game->log.log_input[log_input_index] = '\0';
}
if((input >= 'a' && input <= 'z') || (input >= 'A' && input <= 'Z') || input == ' ') {
game->log.log_input[log_input_index + 1] = input;
game->log.log_input[log_input_index + 2] = '\0';
}
if((input == '\n' || input == KEY_ENTER) && strlen(game->log.log_input) > 0) {
turn_command_t command;
command = execute_command(game, game->log.log_input);
add_log(&(game->log), game->log.log_input);
game->log.log_input[0] = '\0';
log_input_index = 0;
return command;
}
return turn_command_void;
}
void Parse_MTP::mtp_recurse_storage(PCWSTR object_id, IPortableDeviceContent *pdc, bool clear)
{
IEnumPortableDeviceObjectIDs *enum_ids = NULL;
HRESULT hr;
hr = pdc->EnumObjects(0, object_id, NULL, &enum_ids);
if (FAILED(hr))
{
emit add_log(LOG_ERROR, QString("mtp_recurse_storage: Failed to get objects from PDC: %1")
.arg(hr, 0, 16));
return;
}
mtp_get_metadata(object_id, pdc, clear);
while (S_OK == hr)
{
const int batch_size = 10;
ULONG num_fetched = 0;
PWSTR object_ids[batch_size] = {0};
hr = enum_ids->Next(batch_size, object_ids, &num_fetched);
if (SUCCEEDED(hr))
{
for (ULONG i = 0; i < num_fetched; i++)
{
mtp_recurse_storage(object_ids[i], pdc, clear);
CoTaskMemFree(object_ids[i]);
object_ids[i] = NULL;
}
}
}
}
/*
* parse sfb options
*/
int parse_tca_options_sfb(char *msg, char **mp, struct rtattr *tca)
{
struct rtattr *sfb[__TCA_NETEM_MAX];
parse_nested_rtattr(sfb, TCA_SFB_MAX, tca);
if(sfb[TCA_SFB_PARMS]) {
struct tc_sfb_qopt *qopt;
char rehash[MAX_STR_SIZE];
char warmup[MAX_STR_SIZE];
if(RTA_PAYLOAD(sfb[TCA_SFB_PARMS]) < sizeof(*qopt)) {
rec_log("error: %s: TCA_SFB_PARMS: payload too short", __func__);
return(1);
}
qopt = (struct tc_sfb_qopt *)RTA_DATA(sfb[TCA_SFB_PARMS]);
conv_unit_usec(rehash, sizeof(rehash), qopt->rehash_interval * 1000);
conv_unit_usec(warmup, sizeof(warmup), qopt->warmup_time * 1000);
*mp = add_log(msg, *mp, "limit=%u(packet) max=%u(packet) "
"target=%u(packet) increment=%.5f decrement=%.5f "
"penalty-rate=%u(packet/s) penalty-burst=%u(packet) "
"rehash=%s warmup=%s ",
qopt->limit, qopt->max, qopt->bin_size,
(double)qopt->increment / SFB_MAX_PROB,
(double)qopt->decrement / SFB_MAX_PROB,
qopt->penalty_rate, qopt->penalty_burst,
rehash, warmup);
}
return(0);
}
void Parse_MTP::mtp_device_name(DWORD index, LPCWSTR device_id)
{
// model is sometimes the "friendly" name, or just manufacturers model name
DWORD name_len = 256;
WCHAR *name = new (std::nothrow) WCHAR[name_len];
QString make, model, desc;
HRESULT hr = pdm->GetDeviceManufacturer(device_id, name, &name_len);
if (SUCCEEDED(hr))
make = QString::fromWCharArray(name, name_len);
// Reset name_len back to the starting size
name_len = 256;
hr = pdm->GetDeviceFriendlyName(device_id, name, &name_len);
if (SUCCEEDED(hr))
model = QString::fromWCharArray(name, name_len);
name_len = 256;
hr = pdm->GetDeviceDescription(device_id, name, &name_len);
if (SUCCEEDED(hr))
desc = QString::fromWCharArray(name, name_len);
delete [] name;
emit add_log(LOG_INFO,
QString("Device %1: %2 - %3 - %4")
.arg(index)
.arg(make, model, desc));
}
rt_public void app_tpipe(STREAM *stream)
{
/* Initialize the file descriptor to be used in data exchanges with the
* remote process. This enables us to omit this parameter whenever an I/O
* with the remote process has to be made.
*/
if (app_sp != NULL) {
unregister_packet_functions (app_sp);
close_stream (app_sp);
}
if (stream != NULL) {
app_sp = stream;
register_packet_functions (app_sp, &app_send_packet, &app_recv_packet);
} else {
app_sp = (STREAM *) 0;
};
#ifdef DEBUG
#ifdef USE_ADD_LOG
add_log(20, "stream set up as (rd = #%d, wr = #%d)",
readfd(app_sp), writefd(app_sp));
#endif
#endif
}
void GetTrackInfo::get_finished(QNetworkReply *reply)
{
int elapsed = time.elapsed();
if ( reply->error() != QNetworkReply::NoError ) {
emit add_log(LOG_ERROR, tr("API: Failed to download track length: %1")
.arg(reply->errorString()));
emit finished(index, false, 0, elapsed);
return;
}
QString result(reply->readAll());
reader->addData(result);
reader->readNext();
if (reader->atEnd())
{
emit add_log(LOG_ERROR, tr("API: Empty XML"));
emit finished(index, false, 0, elapsed);
return;
}
QString status;
int length = 0;
while (!reader->atEnd())
{
if (reader->isStartElement())
{
if (reader->name() == "lfm")
{
QXmlStreamAttributes attributes = reader->attributes();
status = attributes.value("status").toString();
}
if (reader->name() == "duration")
{
length = reader->readElementText().toInt()/1000;
}
}
reader->readNext();
}
emit add_log(LOG_TRACE, QString("API: %1 is %2, took %3")
.arg(index)
.arg(length)
.arg(elapsed/1000.0));
if (status.startsWith("ok"))
emit finished(index, true, length, elapsed);
else
emit finished(index, false, 0, elapsed);
}
rt_private Signal_t broken(int sig)
{
#ifdef USE_ADD_LOG
add_log(20, "SIGPIPE signal handler broken() called in network.c");
#endif
longjmp(env, 1); /* SIGPIPE was received */
/* NOTREACHED */
}
/*
* parse ematch meta
*/
int parse_ematch_meta(char *msg, char *mp, void *p, int len)
{
struct rtattr *meta[__TCA_EM_META_MAX];
struct tcf_meta_hdr *hdr = NULL;
struct tcf_meta_val *left = NULL, *right = NULL;
parse_rtattr(meta, TCA_EM_META_MAX, p, len);
if(meta[TCA_EM_META_HDR]) {
if(RTA_PAYLOAD(meta[TCA_EM_META_HDR]) < sizeof(*hdr)) {
rec_log("error: %s: TCA_EM_META_HDR: payload too short", __func__);
return(1);
}
hdr = (struct tcf_meta_hdr *)RTA_DATA(meta[TCA_EM_META_HDR]);
left = &(hdr->left);
right = &(hdr->right);
} else {
rec_log("error: %s: TCA_EM_META_HDR: no attribute", __func__);
return(1);
}
mp = add_log(msg, mp, "match=(");
if(meta[TCA_EM_META_LVALUE]) {
if(parse_tca_em_meta_value(msg, &mp, left, meta[TCA_EM_META_LVALUE]))
return(1);
} else {
rec_log("error: %s: TCA_EM_META_LVALUE: no attribute", __func__);
return(1);
}
mp = add_log(msg, mp, "%s ", conv_tcf_em_opnd(left->op, 0));
if(meta[TCA_EM_META_RVALUE]) {
if(parse_tca_em_meta_value(msg, &mp, right, meta[TCA_EM_META_RVALUE]))
return(1);
} else {
rec_log("error: %s: TCA_EM_META_RVALUE: no attribute", __func__);
return(1);
}
mp = add_log(msg, mp, ") ");
rec_log("%s", msg);
return(0);
}
/*
* parse traffic control message
*/
int parse_tcamsg(struct nlmsghdr *nlh)
{
struct tcamsg *tcam;
int tcam_len;
struct rtattr *tcaa[TCAA_MAX+1];
char msg[MAX_MSG_SIZE] = "";
char *mp = msg;
int log_opts = get_log_opts();
/* debug nlmsghdr */
if(log_opts & L_DEBUG)
debug_nlmsg(0, nlh);
/* get tcamsg */
tcam_len = NLMSG_PAYLOAD(nlh, 0);
if(tcam_len < sizeof(*tcam)) {
rec_log("error: %s: length too short", __func__);
return(1);
}
tcam = (struct tcamsg *)NLMSG_DATA(nlh);
/* parse traffic control action message attributes */
parse_tca(tcaa, nlh);
/* debug tcamsg */
if(log_opts & L_DEBUG)
debug_tcamsg(0, tcam, tcaa, tcam_len);
/* kind of message */
switch(nlh->nlmsg_type) {
case RTM_NEWACTION:
mp = add_log(msg, mp, "tc action added: ");
break;
case RTM_DELACTION:
mp = add_log(msg, mp, "tc action deleted: ");
break;
default:
return(1);
}
if(tcaa[TCA_ACT_TAB])
if(parse_tca_acts(msg, mp, tcaa[TCA_ACT_TAB]))
return(1);
return(0);
}
/*
* parse attribute TCA_*_MASK
*/
int parse_tca_mask(char *msg, char **mp, struct rtattr *tca)
{
if(RTA_PAYLOAD(tca) < sizeof(unsigned)) {
rec_log("error: %s: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "mask=0x%08x ", *(unsigned *)RTA_DATA(tca));
return(0);
}
/*
* parse attribute TCA_FLOW_PERTURB
*/
int parse_tca_flow_perturb(char *msg, char **mp, struct rtattr *flow)
{
if(RTA_PAYLOAD(flow) < sizeof(unsigned)) {
rec_log("error: %s: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "perturb=%u(sec) ", *(unsigned *)RTA_DATA(flow));
return(0);
}
/*
* parse attribute TCA_FLOW_KEYS
*/
int parse_tca_flow_keys(char *msg, char **mp, struct rtattr *flow)
{
if(RTA_PAYLOAD(flow) < sizeof(unsigned)) {
rec_log("error: %s: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "keys=%s ", conv_flow_key(*(unsigned *)RTA_DATA(flow), 0));
return(0);
}
/*
* parse red options
*/
int parse_tca_options_red(char *msg, char **mp, struct rtattr *tca)
{
struct rtattr *red[__TCA_RED_MAX];
parse_nested_rtattr(red, TCA_RED_MAX, tca);
if(red[TCA_RED_PARMS]) {
struct tc_red_qopt *qopt;
char limit[MAX_STR_SIZE] = "";
char min[MAX_STR_SIZE] = "";
char max[MAX_STR_SIZE] = "";
char list[MAX_STR_SIZE] = "";
if(RTA_PAYLOAD(red[TCA_RED_PARMS]) < sizeof(*qopt)) {
rec_log("error: %s: TCA_RED_PARMS: payload too short", __func__);
return(1);
}
qopt = (struct tc_red_qopt *)RTA_DATA(red[TCA_RED_PARMS]);
conv_unit_size(limit, sizeof(limit), qopt->limit);
conv_unit_size(min, sizeof(min), qopt->qth_min);
conv_unit_size(max, sizeof(max), qopt->qth_max);
*mp = add_log(msg, *mp, "limit=%s min=%s max=%s ", limit, min, max);
if(qopt->flags) {
conv_tc_red_flags(qopt->flags, list, sizeof(list), 0);
*mp = add_log(msg, *mp, "flag=%s ", list);
}
}
#if HAVE_DECL_TCA_RED_MAX_P
if(red[TCA_RED_MAX_P]) {
if(RTA_PAYLOAD(red[TCA_RED_MAX_P]) < sizeof(unsigned)) {
rec_log("error: %s: TCA_RED_MAX_P: payload too short", __func__);
return(1);
}
*mp = add_log(msg, *mp, "probability=%g(%%) ",
*(unsigned *)RTA_DATA(red[TCA_RED_MAX_P]) / pow(2, 32) * 100);
}
#endif
return(0);
}
rt_private int get_pipe_events (char* id, HANDLE* p_event_r, HANDLE* p_event_w)
{
HANDLE event_r, event_w;
CHAR event_str [128];
unsigned int debuggee_pid;
DWORD count;
/* debuggee/application date */
debuggee_pid = (unsigned int) GetCurrentProcessId();
/* Get Semaphore */
event_r = NULL;
/* NT 3.51 is really fast - at this point we know we were launched by ebench.
lets wait for it to catch up with us */
sprintf (event_str, "eif_event_w%x_%s", debuggee_pid, id);
for (count = 0; (event_r == NULL) && (count < 10); count++) {
event_r = OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, event_str);
if (event_r == NULL)
Sleep(500);
}
if (event_r == NULL) {
#ifdef USE_ADD_LOG
add_log(12, "not started from wrapper - no read event %d", GetLastError());
#endif
return -1;
}
sprintf (event_str, "eif_event_r%x_%s", debuggee_pid, id);
event_w = OpenSemaphore (SEMAPHORE_ALL_ACCESS, FALSE, event_str);
if (event_w == NULL) {
#ifdef USE_ADD_LOG
add_log(12, "not started from wrapper - no write event");
#endif
return -1;
}
*p_event_r = event_r;
*p_event_w = event_w;
return 0;
}
void obj_log( char_data* ch, int i, const char* string )
{
char file [ ONE_LINE ];
if( string != empty_string ) {
sprintf( file, "%sobj.%d", OBJ_LOG_DIR, i );
add_log( "Obj_Log", file, ch, string );
}
return;
}
void room_log( char_data* ch, int i, const char* string )
{
char file [ ONE_LINE ];
if( string != empty_string ) {
sprintf( file, "%sroom.%d", ROOM_LOG_DIR, i );
add_log( "Room_Log", file, ch, string );
}
return;
}
void mob_log( char_data* ch, int i, const char* string )
{
char file [ ONE_LINE ];
if( string != empty_string ) {
sprintf( file, "%smob.%d", MOB_LOG_DIR, i );
add_log( "Mob_Log", file, ch, string );
}
return;
}
