STDCALL void
ExInitializeNPagedLookasideList(struct npaged_lookaside_list *lookaside,
LOOKASIDE_ALLOC_FUNC *alloc_func,
LOOKASIDE_FREE_FUNC *free_func,
unsigned long flags, unsigned long size,
unsigned long tag, unsigned short depth)
{
DBGTRACE("%s: Entry, lookaside: %p, size: %lu, flags: %lu,"
" head: %p, size of lookaside: %u\n",
__FUNCTION__, lookaside, size, flags,
lookaside->head.list.next, sizeof(struct npaged_lookaside_list));
memset(lookaside, 0, sizeof(*lookaside));
lookaside->size = size;
lookaside->tag = tag;
lookaside->depth = 4;
lookaside->maxdepth = 256;
if (alloc_func)
lookaside->alloc_func = alloc_func;
else
lookaside->alloc_func = lookaside_def_alloc_func;
if (free_func)
lookaside->free_func = free_func;
else
lookaside->free_func = lookaside_def_free_func;
KeInitializeSpinLock(&lookaside->obsolete);
DBGTRACE("%s: Exit\n", __FUNCTION__);
return ;
}
STDCALL int RtlUnicodeStringToAnsiString(struct ustring *dst, struct ustring *src, unsigned int dup)
{
int i, *s;
DBGTRACE("%s dup: %d src->len: %d dst: %p", __FUNCTION__, dup, src->len, dst);
if(dup)
{
char *buf = kmalloc(src->buflen, GFP_KERNEL);
if(!buf)
return NDIS_STATUS_FAILURE;
dst->buf = buf;
dst->len = 0;
dst->buflen = src->buflen;
}
s = (int*) src->buf;
for(i = 0; i < src->len; i++)
{
dst->buf[i] = s[i];
}
dst->len = i;
dst->buf[i] = 0;
DBGTRACE(" buf: %s\n", dst->buf);
return NDIS_STATUS_SUCCESS;
}
void Test()
{
DBGTRACE(_T("--------------------------------------------------"));
Variant _int(99);
DBGTRACE(_T("%s : %d"), _int.GetString().c_str(), _int.GetInt());
Variant _float(1.5f);
DBGTRACE(_T("%s : %f"), _float.GetString().c_str(), _float.GetFloat());
Variant _bool(true);
DBGTRACE(_T("%s : %d"), _bool.GetString().c_str(), _bool.GetBool());
}
STDCALL void
ExDeleteNPagedLookasideList(struct npaged_lookaside_list *lookaside)
{
struct slist_entry *entry, *p;
DBGTRACE("%s: Entry, lookaside = %p\n", __FUNCTION__, lookaside);
entry = lookaside->head.list.next;
while (entry)
{
p = entry;
entry = entry->next;
lookaside->free_func(p);
}
DBGTRACE("%s: Exit\n", __FUNCTION__);
}
static inline void
unmap_chunk(struct mc_chunk *chunk)
{
DBGTRACE("%s(%d): unmap cache:%p chunk:%p\n",
__func__, __LINE__, chunk->cache, chunk);
munmap(chunk, chunk->size);
}
STDCALL int RtlAnsiStringToUnicodeString(struct ustring *dst, struct ustring *src, unsigned int dup)
{
int i, *d;
DBGTRACE("%s: dup: %d src: %s\n", __FUNCTION__, dup, src->buf);
if(dup)
{
char *buf = kmalloc((src->buflen+1) * 2, GFP_KERNEL);
if(!buf)
return NDIS_STATUS_FAILURE;
dst->buf = buf;
dst->buflen = (src->buflen+1) * 2;
}
d = (int*) dst->buf;
for(i = 0; i < src->len; i++)
{
d[i] = src->buf[i];
}
d[i] = 0;
dst->len = i*2;
return NDIS_STATUS_SUCCESS;
}
void proxy_handoff_chain(buf_t **in, proxy_t *p) {
DBGTRACE();
req_t *parent;
parent = p->parent;
req_handoff_proxy_chain(parent, p, *in);
*in = NULL;
}
void Test()
{
DBGTRACE(_T("--------------------------------------------------"));
Hoge hoge1;
// Hoge hoge2(hoge1); // NG!
}
void send_dummy_request(conn_t *c) {
DBGTRACE();
buf_t *b;
int len = strlen(dummy_req);
b = buf_new_shadow(dummy_req, dummy_req + len);
conn_write_chain(c, b);
}
void CFlukeSlave::Create(HMODULE h)
{
DBGTRACE("FlukeInit(%08x)\n",h);
if(h==0)
h=GetCurrentModuleHandle();
flukeslave(h);
}
void proxy_connect_handler(conn_t *c, void *data) {
DBGTRACE();
proxy_t *p = c->data;
proxy_send_request(p);
c->read_close_handler = proxy_read_close_handler;
c->write_handler = NULL;
conn_read(c, proxy_read_handler);
}
void proxy_read_close_handler(conn_t *c, void *data) {
DBGTRACE();
proxy_t *p = c->data;
proxy_close(p);
conn_read_done(c);
c->read_close_handler = NULL;
c->close_connection = 1;
}
STDCALL int KeCancelTimer(struct ktimer *ktimer)
{
char canceled;
DBGTRACE("%s(entry): %p\n", __FUNCTION__, ktimer);
wrapper_cancel_timer(ktimer->wrapper_timer, &canceled);
return canceled;
}
void CBody::GetBody(const char* dllname)
{
DBGTRACE("before make body\n");
int start1,end1;
GetLibraryBody(&start1,&end1);
DBGTRACE("maked code %d\n",end1-start1);
const unsigned char* start;
int size;
GetLoadLibraryA(&start,&size);
m_body.clear();
m_body.insert(m_body.end(),start,start+size);
m_body.insert(m_body.end(),reinterpret_cast<const unsigned char*>(dllname),reinterpret_cast<const unsigned char*>(strchr(dllname,0)+1));
DBGTRACE("maked total %d\n",m_body.size());
}
/*
*
*
* Called from the driver entry.
*/
STDCALL void NdisInitializeWrapper(struct ndis_handle **ndis_handle,
void *SystemSpecific1,
void *SystemSpecific2,
void *SystemSpecific3)
{
DBGTRACE("%s handle=%08x, SS1=%08x, SS2=%08x\n", __FUNCTION__, (int)ndis_handle, (int)SystemSpecific1, (int)SystemSpecific2);
*ndis_handle = (struct ndis_handle*) SystemSpecific1;
}
STDCALL void NdisOpenConfiguration(unsigned int *status,
void **confhandle,
struct ndis_handle *handle)
{
DBGTRACE("%s: Handle: %08x\n", __FUNCTION__, (int) handle);
*confhandle = (void*) handle;
*status = NDIS_STATUS_SUCCESS;
}
void proxy_close(proxy_t *p) {
DBGTRACE();
req_t *parent;
parent = p->parent;
debug("[%s] p: %p, parent: %p\n", __FUNCTION__, p, parent);
proxy_handoff_chain(&p->conn->in, p);
req_proxy_finished(parent, p);
}
void CFlukeSlave::flukeslave(HMODULE hmod)
{
DBGTRACE("CFlukeSlave::flukeslave\n");
CSyncClient sync1("IOFlukeApp",GetCurrentThreadId());
DBGTRACE("sync1.IsExist()==%s\n",sync1.IsExist()?"true":"false");
if(!sync1.IsExist())
return;
char name[MAX_PATH];
DWORD sname=GetModuleFileName(hmod,name,sizeof(name));
if(sname==0||(sname==sizeof(name)))
throw FlukeException("Path Test");
DBGTRACE("LoadLibrary(%s)\n",name);
m_library=LoadLibrary(name);
CSyncServer sync2("IOFlukeDll",GetCurrentThreadId());
DBGTRACE("sync1.RunClient()\n",hmod);
sync1.RunClient();
DBGTRACE("sync2.WaitClient()\n",hmod);
sync2.WaitClient();
std::ostringstream str;
str<<g_flukeslaveready<<GetCurrentThreadId();
DBGTRACE("m_globalpass: %s\n",str.str().c_str());
m_globalpass=CreateMutex(0,TRUE,str.str().c_str());
DBGTRACE("InitInstance(%08x)\n",hmod);
FlukeInit(hmod);
}
STDCALL void KeAcquireSpinLock(KSPIN_LOCK *lock, KIRQL *irql)
{
DBGTRACE("%s: lock = %p, *lock = %p\n", __FUNCTION__, lock, (void *)*lock);
if (lock && *lock)
spin_lock((spinlock_t *)(*lock));
else
printk(KERN_ERR "%s: lock %p is not initialized?\n",
__FUNCTION__, lock);
}
void Test()
{
DBGTRACE(_T("--------------------------------------------------"));
Properties props;
props.AddProperty(_T("hoge"), 0);
props.AddProperty(_T("fuga"), 1);
props[_T("piyo")].SetString(_T("piyopiyo"));
Variant* hoge = props.GetProperty(_T("hoge"));
DBGTRACE(_T("hoge=%d"), hoge->GetInt());
Variant* fuga = props.GetProperty(_T("fuga"));
DBGTRACE(_T("fuga=%d"), fuga->GetInt());
DBGTRACE(_T("piyo=%s"), props[_T("piyo")].GetString().c_str());
}
STDCALL int IoIsWdmVersionAvailable(unsigned char major, unsigned char minor)
{
DBGTRACE("%s: %d, %d\n", __FUNCTION__, major, minor);
if (major == 1 &&
(minor == 0x30 || // Windows 2003
minor == 0x20 || // Windows XP
minor == 0x10)) // Windows 2000
return 1;
return 0;
}
void Test()
{
DBGTRACE(_T("--------------------------------------------------"));
MyThread my1, my2;
my1.Start();
Sleep(10);
my2.Start();
if (!my2.Start()) { DBGTRACE(_T("failed.")); }
while (!my1.IsEnd() || !my2.IsEnd()) {
Sleep(10);
}
//my1.Start();
//while (!my1.IsEnd()) {
// Sleep(10);
//}
}
_FASTCALL struct slist_entry *
ExInterlockedPushEntrySList(int dummy,
struct slist_entry *entry,union slist_head *head,
KSPIN_LOCK *lock)
{
struct slist_entry *oldhead;
KIRQL irql;
DBGTRACE("%s Entry: head = %p, entry = %p\n", __FUNCTION__, head, entry);
// __asm__ __volatile__ ("" : "=c" (head), "=d" (entry));
KeAcquireSpinLock(lock, &irql);
oldhead = head->list.next;
entry->next = head->list.next;
head->list.next = entry;
KeReleaseSpinLock(lock, &irql);
DBGTRACE("%s exit head = %p, oldhead = %p\n", __FUNCTION__, head, oldhead);
return(oldhead);
}
STDCALL void KeInitializeSpinLock(KSPIN_LOCK *lock)
{
spinlock_t *spin_lock;
DBGTRACE("%s: lock = %p, *lock = %p\n", __FUNCTION__, lock, *lock);
if (!lock)
printk(KERN_ERR "%s: lock %p is not valid pointer?\n",
__FUNCTION__, lock);
spin_lock = wrap_kmalloc(sizeof(spinlock_t), GFP_KERNEL);
if (!spin_lock)
printk(KERN_ERR "%s: couldn't allocate space for spinlock\n",
__FUNCTION__);
else
{
DBGTRACE("%s: allocated spinlock %p\n", __FUNCTION__, spin_lock);
spin_lock_init(spin_lock);
*lock = (KSPIN_LOCK)spin_lock;
}
}
void Test()
{
DBGTRACE(_T("--------------------------------------------------"));
Fuga fuga;
Piyo piyo;
Hoge* pHogeFuga = up_cast<Hoge*>(&fuga);
Hoge* pHogePiyo = up_cast<Hoge*>(&piyo);
Fuga* pFugaFuga = down_cast<Fuga*>(pHogeFuga); // OK
//Fuga* pFugaPiyo = down_cast<Fuga*>(pHogePiyo); // NG
}
STDCALL void *MmMapIoSpace(__s64 phys_addr,
unsigned long size, int cache)
{
void *virt;
if (cache)
virt = ioremap(phys_addr, size);
else
virt = ioremap_nocache(phys_addr, size);
DBGTRACE("%s: %Lx, %lu, %d: %p\n",
__FUNCTION__, phys_addr, size, cache, virt);
return virt;
}
int IterativeServer::callIOhandler(int socket, fd_set &master_fds, IOHS &handlers,
fd_set &master_fds2, fd_set &master_fds3)
{
DBGTRACE();
IOHS::iterator ioit = handlers.find(socket);
if (ioit == handlers.end())
{
DBGTRACE();
return(0);
}
UseCntPtr<EndPoint> pendpoint = ioit->second.first;
UseCntPtr<BaseIOHandler> phandler = ioit->second.second;
DBGTRACE();
int status = phandler->handler(pendpoint);
DBGPRINTF("callIOHandler: status = %d\n", status);
if (status > 0)
{
DBGTRACE();
// success and done with this server
cleanup(socket, master_fds, master_fds2, master_fds3, pendpoint);
}
else if (status < 0)
{
DBGTRACE();
// some type of error. for now, close endpoint
cleanup(socket, master_fds, master_fds2, master_fds3, pendpoint);
}
DBGTRACE();
return(status);
}
_FASTCALL struct slist_entry *
ExInterlockedPopEntrySList(int dummy, KSPIN_LOCK *lock,union slist_head *head)
{
struct slist_entry *first;
KIRQL irql;
DBGTRACE("%s: head = %p\n", __FUNCTION__, head);
// __asm__ __volatile__ ("" : "=c" (head));
KeAcquireSpinLock(lock, &irql);
first = NULL;
if (head)
{
first = head->list.next;
if (first)
{
head->list.next = first->next;
}
}
KeReleaseSpinLock(lock, &irql);
DBGTRACE("%s: Exit, returning %p\n", __FUNCTION__, first);
return first;
}
static inline void
link_cache(struct mcache *parent,
struct mcache *cache)
{
if (parent) {
DBGTRACE("%s(%d): cache:%p %s\n",
__func__, __LINE__, cache, cache->name);
TAILQ_INSERT_TAIL(&parent->childs, cache, node);
parent->child_num++;
cache->parent = parent;
}
}
/*
* Register a miniport with NDIS.
*
* Called from driver entry
*/
STDCALL int NdisMRegisterMiniport(struct ndis_driver *ndis_driver,
struct miniport_char *miniport_char,
unsigned int char_len)
{
DBGTRACE("%s driver: %08x\n", __FUNCTION__, (int)ndis_driver);
if(miniport_char->majorVersion < 4)
{
return NDIS_STATUS_BAD_VERSION;
}
if(char_len < sizeof(struct miniport_char))
{
return NDIS_STATUS_BAD_CHAR;
}
printk(KERN_INFO "Version %d.%d\n", miniport_char->majorVersion, miniport_char->minorVersion);
DBGTRACE("Len: %08x:%08x\n", char_len, sizeof(struct miniport_char));
memcpy(&ndis_driver->miniport_char, miniport_char, sizeof(struct miniport_char));
return NDIS_STATUS_SUCCESS;
}
