static int host_command_get_version(struct host_cmd_handler_args *args)
{
struct ec_response_get_version *r = args->response;
strzcpy(r->version_string_ro, system_get_version(SYSTEM_IMAGE_RO),
sizeof(r->version_string_ro));
strzcpy(r->version_string_rw, system_get_version(SYSTEM_IMAGE_RW),
sizeof(r->version_string_rw));
switch (system_get_image_copy()) {
case SYSTEM_IMAGE_RO:
r->current_image = EC_IMAGE_RO;
break;
case SYSTEM_IMAGE_RW:
r->current_image = EC_IMAGE_RW;
break;
default:
r->current_image = EC_IMAGE_UNKNOWN;
break;
}
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
static piXping * piFindXping
(
PEER peer,
const char * nick1,
const char * nick2
)
{
piXping xpingMatch;
PEER_CONNECTION;
assert(nick1);
assert(nick1[0]);
assert(piGetPlayer(peer, nick1));
assert(nick2);
assert(nick2[0]);
assert(piGetPlayer(peer, nick2));
// Setup the xping match.
/////////////////////////
strzcpy(xpingMatch.nicks[0], nick1, PI_NICK_MAX_LEN);
_strlwr(xpingMatch.nicks[0]);
strzcpy(xpingMatch.nicks[1], nick2, PI_NICK_MAX_LEN);
_strlwr(xpingMatch.nicks[0]);
// Find the xping.
//////////////////
return (piXping *)TableLookup(connection->xpings, &xpingMatch);
}
static int host_command_get_chip_info(struct host_cmd_handler_args *args)
{
struct ec_response_get_chip_info *r = args->response;
strzcpy(r->vendor, system_get_chip_vendor(), sizeof(r->vendor));
strzcpy(r->name, system_get_chip_name(), sizeof(r->name));
strzcpy(r->revision, system_get_chip_revision(), sizeof(r->revision));
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
static int host_command_build_info(struct host_cmd_handler_args *args)
{
strzcpy(args->response, system_get_build_info(), args->response_max);
args->response_size = strlen(args->response) + 1;
return EC_RES_SUCCESS;
}
GPResult
gpiSendServerBuddyMessage(
GPConnection * connection,
int profileid,
int type,
const char * message
)
{
char buffer[3501];
GPIConnection * iconnection = (GPIConnection*)*connection;
// Copy the message into an internal buffer.
////////////////////////////////////////////
strzcpy(buffer, message, sizeof(buffer));
// Setup the message.
/////////////////////
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, "\\bm\\");
gpiAppendIntToBuffer(connection, &iconnection->outputBuffer, type);
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, "\\sesskey\\");
gpiAppendIntToBuffer(connection, &iconnection->outputBuffer, iconnection->sessKey);
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, "\\t\\");
gpiAppendIntToBuffer(connection, &iconnection->outputBuffer, profileid);
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, "\\msg\\");
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, buffer);
gpiAppendStringToBuffer(connection, &iconnection->outputBuffer, "\\final\\");
return GP_NO_ERROR;
}
ret_t threading_setup(uint32_t init_thread_stack_base_address,
uint32_t init_thread_stack_size)
{
struct thread *myself;
TAILQ_INIT(&kernel_threads);
/* Allocate a new thread structure for the current running thread */
myself = (struct thread *)malloc(sizeof(struct thread));
if (!myself)
return -KERNEL_NO_MEMORY;
/* Initialize the thread attributes */
strzcpy(myself->name, "[kinit]", THREAD_MAX_NAMELEN);
myself->state = THREAD_CREATED;
myself->kernel_stack_base_address = init_thread_stack_base_address;
myself->kernel_stack_size = init_thread_stack_size;
/* Add the thread in the global list */
TAILQ_INSERT_TAIL(&kernel_threads, myself, next);
/* Ok, now pretend that the running thread is ourselves */
myself->state = THREAD_READY;
thread_set_current(myself);
return KERNEL_OK;
}
void handle_allnames( Client *client, PKTBI_98_IN *msg )
{
u32 serial = cfBEu32( msg->serial );
Character *the_mob = find_character( serial );
if (the_mob != NULL)
{
if (!client->chr->is_visible_to_me(the_mob)) {
return;
}
if (pol_distance(client->chr->x, client->chr->y, the_mob->x, the_mob->y) > 20) {
return;
}
PKTBI_98_OUT allnames;
allnames.msgtype = PKTBI_98_OUT_ID;
allnames.msglen = ctBEu16(0x25); // 0x25 = 37. Static Length.
allnames.serial = the_mob->serial_ext;
strzcpy( allnames.name, the_mob->name().c_str(), sizeof allnames.name );
transmit( client, &allnames, sizeof allnames );
}
else
{
return;
}
}
struct thread *thread_create(const char *name,
kernel_thread_start_routine_t start_func,
void *start_arg)
{
__label__ undo_creation;
uint32_t flags;
struct thread *new_thread;
if (!start_func)
return NULL;
/* Allocate a new thread structure for the current running thread */
new_thread = malloc(sizeof(struct thread));
if (!new_thread)
return NULL;
/* Initialize the thread attributes */
strzcpy(new_thread->name, ((name)?name:"[NONAME]"), THREAD_MAX_NAMELEN);
new_thread->state = THREAD_CREATED;
/* Allocate the stack for the new thread */
new_thread->kernel_stack_base_address = (uint32_t)malloc(THREAD_KERNEL_STACK_SIZE);
new_thread->kernel_stack_size = THREAD_KERNEL_STACK_SIZE;
if (!new_thread->kernel_stack_base_address)
goto undo_creation;
/* Initialize the CPU context of the new thread */
cpu_kstate_init(&new_thread->cpu_state,
(cpu_kstate_function_arg1_t *)start_func,
(uint32_t)start_arg,
new_thread->kernel_stack_base_address,
new_thread->kernel_stack_size);
/* Add the thread in the global list */
X86_IRQs_DISABLE(flags);
TAILQ_INSERT_TAIL(&kernel_threads, new_thread, next);
X86_IRQs_ENABLE(flags);
/* Mark the thread as ready */
if (scheduler_set_ready(new_thread) != KERNEL_OK)
goto undo_creation;
return new_thread;
undo_creation:
if (new_thread->kernel_stack_base_address)
free((uint32_t *)new_thread->kernel_stack_base_address);
free(new_thread);
return NULL;
}
static piXping * piAddXping
(
PEER peer,
const char * nick1,
const char * nick2
)
{
piXping xpingMatch;
piXping * xping;
PEER_CONNECTION;
assert(nick1);
assert(nick1[0]);
assert(piGetPlayer(peer, nick1));
assert(nick2);
assert(nick2[0]);
assert(piGetPlayer(peer, nick2));
// Setup the one to add.
////////////////////////
xping = &xpingMatch;
strzcpy(xping->nicks[0], nick1, PI_NICK_MAX_LEN);
_strlwr(xping->nicks[0]);
strzcpy(xping->nicks[1], nick2, PI_NICK_MAX_LEN);
_strlwr(xping->nicks[1]);
// Add it.
//////////
TableEnter(connection->xpings, xping);
// Get it.
//////////
xping = (piXping *)TableLookup(connection->xpings, &xpingMatch);
// Return it.
/////////////
return xping;
}
int kwaitq_init(struct kwaitq *kwq,
const char *name)
{
memset(kwq, 0x0, sizeof(struct kwaitq));
if (! name)
name = "<unknown>";
strzcpy(kwq->name, name, KWQ_DEBUG_MAX_NAMELEN);
list_init_named(kwq->waiting_list,
prev_entry_in_kwaitq, next_entry_in_kwaitq);
return OK;
}
int firstcall(char *uname, char *str) {
char *tp;
char buf[32];
memset(buf,0x00,32);
tp=strstr(uname,"\t");
strncpy(buf,uname,tp-uname);
uname=buf;
memset(str, 0x00, MAXBUF+1);
int count=0;
int n=-1;
free(servquery(aserv, NUSER, uname, 1, &count));
if (count==1) {
str=strzcpy(str, "1", -1);
} else {
str=strzcpy(str, "0", -1);
}
free(servquery(aserv, NMIDWARE, "weblogic813", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "weblogic920", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "websphere51", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "websphere61", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "tomcat5", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "tomcat6", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
free(servquery(aserv, NMIDWARE, "weblogic816", n, &count));
str=strzcpy(str, itoas(count, "00"), -1);
str[strlen(str)]='\0';
return 1;
}
void send_short_statmsg( Client *client, Character *chr )
{
unsigned short msglen = offsetof( PKTOUT_11_V1, gender );
PKTOUT_11_V1 msg;
msg.msgtype = PKTOUT_11_V1_ID;
msg.msglen = ctBEu16(msglen);
msg.serial = chr->serial_ext;
strzcpy( msg.name, chr->name().c_str(), sizeof msg.name );
if (uoclient_general.hits.any)
{
long h, mh;
h = chr->vital(uoclient_general.hits.id).current_ones();
if (h > 0xFFFF)
h = 0xFFFF;
//msg.hits = ctBEu16( static_cast<u16>(h) );
mh = chr->vital(uoclient_general.hits.id).maximum_ones();
if (mh > 0xFFFF)
mh = 0xFFFF;
//msg.max_hits = ctBEu16( static_cast<u16>(mh) );
msg.hits = ctBEu16( static_cast<u16>(h * 1000 / mh) );
msg.max_hits = ctBEu16( 1000 );
}
else
{
msg.hits = 0;
msg.max_hits = 0;
}
msg.renameable = (client->chr->can_rename( chr ) ? 0xFF : 0);
msg.moreinfo = 0;
transmit(client, &msg, msglen );
}
int EScriptProgram::write( const char *fname )
{
EScriptProgram& program = *this;
FILE *fp = fopen(fname, "wb");
if (!fp)
return -1;
BSCRIPT_FILE_HDR hdr;
hdr.magic2[0] = BSCRIPT_FILE_MAGIC0;
hdr.magic2[1] = BSCRIPT_FILE_MAGIC1;
hdr.version = ESCRIPT_FILE_VER_CURRENT; // auto-set to latest version (see filefmt.h)
hdr.globals = static_cast<unsigned short>(globalvarnames.size());
fwrite( &hdr, sizeof hdr, 1, fp );
BSCRIPT_SECTION_HDR sechdr;
if (haveProgram)
{
BSCRIPT_PROGDEF_HDR progdef_hdr;
memset( &progdef_hdr, 0, sizeof progdef_hdr );
sechdr.type = BSCRIPT_SECTION_PROGDEF;
sechdr.length = sizeof progdef_hdr;
fwrite( &sechdr, sizeof sechdr, 1, fp );
progdef_hdr.expectedArgs = expectedArgs;
fwrite( &progdef_hdr, sizeof progdef_hdr, 1, fp );
}
for( unsigned idx = 0; idx < program.modules.size(); idx++ )
{
FunctionalityModule* module = program.modules[ idx ];
sechdr.type = BSCRIPT_SECTION_MODULE;
sechdr.length = 0;
fwrite( &sechdr, sizeof sechdr, 1, fp );
BSCRIPT_MODULE_HDR modhdr;
memset( &modhdr, 0, sizeof modhdr );
strzcpy( modhdr.modulename, module->modulename.c_str(), sizeof modhdr.modulename );
modhdr.nfuncs = module->used_functions.size();
fwrite( &modhdr, sizeof modhdr, 1, fp );
for( unsigned funcnum = 0; funcnum < module->used_functions.size(); funcnum++ )
{
BSCRIPT_MODULE_FUNCTION func;
memset( &func, 0, sizeof func );
passert( module->used_functions[funcnum]->used );
strzcpy( func.funcname, module->used_functions[funcnum]->name.c_str(), sizeof func.funcname );
func.nargs = static_cast<unsigned char>(module->used_functions[funcnum]->nargs);
fwrite( &func, sizeof func, 1, fp );
}
}
sechdr.type = BSCRIPT_SECTION_CODE;
sechdr.length = program.tokens.get_write_length();
fwrite( &sechdr, sizeof sechdr, 1, fp );
program.tokens.write(fp);
sechdr.type = BSCRIPT_SECTION_SYMBOLS;
sechdr.length = program.symbols.get_write_length();
fwrite( &sechdr, sizeof sechdr, 1, fp );
program.symbols.write(fp);
if (exported_functions.size())
{
BSCRIPT_EXPORTED_FUNCTION bef;
sechdr.type = BSCRIPT_SECTION_EXPORTED_FUNCTIONS;
sechdr.length = exported_functions.size() * sizeof bef;
fwrite( &sechdr, sizeof sechdr, 1, fp );
for( unsigned i = 0; i < exported_functions.size(); ++i )
{
strzcpy( bef.funcname, exported_functions[i].name.c_str(), sizeof bef.funcname );
bef.nargs = exported_functions[i].nargs;
bef.PC = exported_functions[i].PC;
fwrite( &bef, sizeof bef, 1, fp );
}
}
fclose(fp);
return 0;
}
GPResult
gpiProcessRecvBuddyMessage(
GPConnection * connection,
const char * input
)
{
char buffer[4096];
int type;
int profileid;
time_t date;
GPICallback callback;
GPIProfile * profile;
GPIBuddyStatus * buddyStatus;
char intValue[16];
char * str;
unsigned short port;
int productID;
GPIConnection * iconnection = (GPIConnection*)*connection;
char strTemp[max(GP_STATUS_STRING_LEN, GP_LOCATION_STRING_LEN)];
// Check the type of bm.
////////////////////////
if(!gpiValueForKey(input, "\\bm\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
type = atoi(buffer);
// Get the profile this is from.
////////////////////////////////
if(!gpiValueForKey(input, "\\f\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
profileid = atoi(buffer);
// Get the time.
////////////////
if(!gpiValueForKey(input, "\\date\\", buffer, sizeof(buffer)))
date = time(NULL);
else
date = atoi(buffer);
// What type of message is this?
////////////////////////////////
switch(type)
{
case GPI_BM_MESSAGE:
// Call the callback.
/////////////////////
callback = iconnection->callbacks[GPI_RECV_BUDDY_MESSAGE];
if(callback.callback != NULL)
{
GPRecvBuddyMessageArg * arg;
arg = (GPRecvBuddyMessageArg *)gsimalloc(sizeof(GPRecvBuddyMessageArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
#ifndef GSI_UNICODE
arg->message = (char *)gsimalloc(strlen(buffer) + 1);
if(arg->message == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
strcpy(arg->message, buffer);
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
#else
arg->message = (unsigned short*)gsimalloc(strlen(buffer)*2+2);
if(arg->message == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
UTF8ToUCS2String(buffer, arg->message);
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
#endif
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_MESSAGE));
}
break;
case GPI_BM_UTM:
// Call the callback.
/////////////////////
callback = iconnection->callbacks[GPI_RECV_BUDDY_UTM];
if(callback.callback != NULL)
{
GPRecvBuddyUTMArg * arg;
arg = (GPRecvBuddyUTMArg *)gsimalloc(sizeof(GPRecvBuddyUTMArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
#ifndef GSI_UNICODE
arg->message = (char *)gsimalloc(strlen(buffer) + 1);
if(arg->message == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
strcpy(arg->message, buffer);
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
#else
arg->message = (unsigned short*)gsimalloc(strlen(buffer)*2+2);
if(arg->message == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
UTF8ToUCS2String(buffer, arg->message);
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
#endif
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYUTM));
}
break;
case GPI_BM_REQUEST:
// Get the profile, adding if needed.
/////////////////////////////////////
profile = gpiProfileListAdd(connection, profileid);
if(!profile)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
// Get the reason.
//////////////////
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Find where the sig starts.
/////////////////////////////
str = strstr(buffer, "|signed|");
if(str == NULL)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the sig out of the message.
//////////////////////////////////
*str = '\0';
str += 8;
if(strlen(str) != 32)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
freeclear(profile->authSig);
profile->authSig = goastrdup(str);
profile->requestCount++;
// Call the callback.
/////////////////////
callback = iconnection->callbacks[GPI_RECV_BUDDY_REQUEST];
if(callback.callback != NULL)
{
GPRecvBuddyRequestArg * arg;
arg = (GPRecvBuddyRequestArg *)gsimalloc(sizeof(GPRecvBuddyRequestArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
#ifndef GSI_UNICODE
strzcpy(arg->reason, buffer, GP_REASON_LEN);
#else
UTF8ToUCS2String(buffer, arg->reason);
#endif
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDDYREQUEST));
}
break;
case GPI_BM_AUTH:
// call the callback
callback = iconnection->callbacks[GPI_RECV_BUDDY_AUTH];
if(callback.callback != NULL)
{
GPRecvBuddyAuthArg * arg;
arg = (GPRecvBuddyAuthArg *)gsimalloc(sizeof(GPRecvBuddyAuthArg));
if (arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYAUTH));
}
break;
case GPI_BM_REVOKE:
// call the callback
callback = iconnection->callbacks[GPI_RECV_BUDDY_REVOKE];
if(callback.callback != NULL)
{
GPRecvBuddyRevokeArg * arg;
arg = (GPRecvBuddyRevokeArg *)gsimalloc(sizeof(GPRecvBuddyRevokeArg));
if (arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
arg->profile = (GPProfile)profileid;
arg->date = (unsigned int)date;
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYREVOKE));
}
break;
case GPI_BM_STATUS:
// Get the profile, adding if needed.
/////////////////////////////////////
profile = gpiProfileListAdd(connection, profileid);
if(!profile)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
// Make sure profile wasn't blocked prior to getting the status update
//////////////////////////////////////////////////////////////////////
if (!profile->blocked)
{
// This is a buddy.
///////////////////
if(!profile->buddyStatus)
{
profile->buddyStatus = (GPIBuddyStatus *)gsimalloc(sizeof(GPIBuddyStatus));
if(!profile->buddyStatus)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
memset(profile->buddyStatus, 0, sizeof(GPIBuddyStatus));
if (profile->buddyStatusInfo)
{
profile->buddyStatus->buddyIndex = profile->buddyStatusInfo->buddyIndex;
gpiRemoveBuddyStatusInfo(profile->buddyStatusInfo);
profile->buddyStatusInfo = NULL;
}
else
profile->buddyStatus->buddyIndex = iconnection->profileList.numBuddies++;
}
// Get the buddy status.
////////////////////////
buddyStatus = profile->buddyStatus;
// Get the msg.
///////////////
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the status.
//////////////////
if(!gpiValueForKey(buffer, "|s|", intValue, sizeof(intValue)))
{
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
}
else
{
buddyStatus->status = (GPEnum)atoi(intValue);
}
// Get the status string.
/////////////////////////
freeclear(buddyStatus->statusString);
if(!gpiValueForKey(buffer, "|ss|", strTemp, GP_STATUS_STRING_LEN))
strTemp[0] = '\0';
buddyStatus->statusString = goastrdup(strTemp);
if(!buddyStatus->statusString)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
// Get the location string.
///////////////////////////
freeclear(buddyStatus->locationString);
if(!gpiValueForKey(buffer, "|ls|", strTemp, GP_LOCATION_STRING_LEN))
strTemp[0] = '\0';
buddyStatus->locationString = goastrdup(strTemp);
if(!buddyStatus->locationString)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
// Get the ip.
//////////////
if(!gpiValueForKey(buffer, "|ip|", intValue, sizeof(intValue)))
buddyStatus->ip = 0;
else
buddyStatus->ip = htonl((unsigned int)atoi(intValue));
// Get the port.
////////////////
if(!gpiValueForKey(buffer, "|p|", intValue, sizeof(intValue)))
buddyStatus->port = 0;
else
{
port = (unsigned short)atoi(intValue);
buddyStatus->port = htons(port);
}
// Get the quiet mode flags.
////////////////////////////
if(!gpiValueForKey(buffer, "|qm|", intValue, sizeof(intValue)))
buddyStatus->quietModeFlags = GP_SILENCE_NONE;
else
buddyStatus->quietModeFlags = (GPEnum)atoi(intValue);
// Call the callback.
/////////////////////
callback = iconnection->callbacks[GPI_RECV_BUDDY_STATUS];
if(callback.callback != NULL)
{
GPRecvBuddyStatusArg * arg;
arg = (GPRecvBuddyStatusArg *)gsimalloc(sizeof(GPRecvBuddyStatusArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
arg->profile = (GPProfile)profileid;
arg->index = buddyStatus->buddyIndex;
arg->date = (unsigned int)date;
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_STATUS));
}
}
break;
case GPI_BM_INVITE:
// Get the msg.
///////////////
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Find the productid.
//////////////////////
str = strstr(buffer, "|p|");
if(str == NULL)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Skip the |p|.
////////////////
str += 3;
if(str[0] == '\0')
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the productid.
/////////////////////
productID = atoi(str);
// Find the location string (optional - older versions won't have)
str = strstr(buffer, "|l|");
if(str != NULL)
strzcpy(strTemp, (str+3), sizeof(strTemp));
else
strTemp[0] = '\0'; // no location, set to empty string
// Call the callback.
/////////////////////
callback = iconnection->callbacks[GPI_RECV_GAME_INVITE];
if(callback.callback != NULL)
{
GPRecvGameInviteArg * arg;
arg = (GPRecvGameInviteArg *)gsimalloc(sizeof(GPRecvGameInviteArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
arg->profile = (GPProfile)profileid;
arg->productID = productID;
#ifdef GSI_UNICODE
AsciiToUCS2String(strTemp, arg->location);
#else
strcpy(arg->location, strTemp);
#endif
CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, 0));
}
break;
case GPI_BM_PING:
// Get the msg.
///////////////
if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Send back a pong.
////////////////////
gpiSendBuddyMessage(connection, profileid, GPI_BM_PONG, "1", 0, NULL);
break;
#ifndef NOFILE
case GPI_BM_PONG:
// Lets the transfers handle this.
//////////////////////////////////
gpiTransfersHandlePong(connection, profileid, NULL);
break;
#endif
}
return GP_NO_ERROR;
}
HWND WINAPI
CreateWindowEx(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName,
DWORD dwStyle, int x, int y, int nWidth, int nHeight,
HWND hwndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam)
{
HWND pwp; /* parent window */
HWND wp; /* new window */
HWND hwndOwner;
PWNDCLASS pClass;
CREATESTRUCT cs;
static int nextx = 20;
static int nexty = 20;
pClass = MwFindClassByName(lpClassName);
if(!pClass)
return NULL;
if(x == CW_USEDEFAULT || y == CW_USEDEFAULT) {
x = nextx;
nextx += 10;
y = nexty;
nexty += 10;
if(nextx > 200)
nextx = nexty = 20;
}
if(nWidth == CW_USEDEFAULT || nHeight == CW_USEDEFAULT) {
nWidth = 250;
nHeight = 250;
}
if(hwndParent == NULL) {
if(dwStyle & WS_CHILD)
return NULL;
pwp = rootwp;
} else
pwp = hwndParent;
/* WS_POPUP z-order parent is the root window (passed parent is owner)*/
if(dwStyle & WS_POPUP)
pwp = rootwp; /* force clip to root, not z-parent*/
/* window owner is NULL for child windows, else it's the passed parent*/
if(dwStyle & WS_CHILD)
hwndOwner = NULL;
else hwndOwner = hwndParent;
wp = (HWND)GdItemAlloc(sizeof(struct hwnd) - 1 + pClass->cbWndExtra);
if(!wp)
return NULL;
/* force all clipping on by default*/
dwStyle |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
wp->pClass = pClass;
wp->style = dwStyle;
wp->exstyle = dwExStyle;
wp->parent = pwp;
wp->owner = hwndOwner;
wp->children = NULL;
wp->siblings = pwp->children;
pwp->children = wp;
wp->next = listwp;
listwp = wp;
wp->winrect.left = pwp->clirect.left + x;
wp->winrect.top = pwp->clirect.top + y;
wp->winrect.right = wp->winrect.left + nWidth;
wp->winrect.bottom = wp->winrect.top + nHeight;
wp->cursor = pwp->cursor;
wp->cursor->usecount++;
wp->unmapcount = pwp->unmapcount + 1;
wp->id = (int)hMenu;
wp->gotPaintMsg = PAINT_PAINTED;
strzcpy(wp->szTitle, lpWindowName, sizeof(wp->szTitle));
#if UPDATEREGIONS
wp->update = GdAllocRegion();
#endif
wp->nextrabytes = pClass->cbWndExtra;
/* calculate client area*/
MwCalcClientRect(wp);
cs.lpCreateParams = lpParam;
cs.hInstance = hInstance;
cs.hMenu = hMenu;
cs.hwndParent = hwndParent;
cs.cy = nHeight;
cs.cx = nWidth;
cs.y = y;
cs.x = x;
cs.style = dwStyle;
cs.lpszName = lpWindowName;
cs.lpszClass = lpClassName;
cs.dwExStyle = dwExStyle;
if(SendMessage(wp, WM_CREATE, 0, (LPARAM)(LPSTR)&cs) == -1) {
MwDestroyWindow(wp, FALSE);
return NULL;
}
/* send SIZE and MOVE msgs*/
MwSendSizeMove(wp, TRUE, TRUE);
if(wp->style & WS_VISIBLE) {
MwShowWindow(wp, TRUE);
SetFocus(wp);
}
return wp;
}
void set_ip_address( const char* ip )
{
strzcpy( ipaddr_str, ip, sizeof ipaddr_str );
cout << "Internet IP address is " << ipaddr_str << endl;
}
void set_lan_address( const char* ip )
{
strzcpy( lanaddr_str, ip, sizeof lanaddr_str );
cout << "LAN IP address is " << lanaddr_str << endl;
}
char *mergeFnExt( char *fname )
{
strzcpy( fname, temp_fname, MAXFILE );
strncat( fname, temp_ext, MAXEXT - 1 );
return fname;
}
/* XXX fixme: this function uses obsolete argument parsing interface */
int acpi_table_add(const char *t)
{
char buf[1024], *p, *f;
unsigned long val;
size_t len, start, allen;
bool has_header;
int changed;
int r;
struct acpi_table_header hdr;
r = 0;
r |= get_param_value(buf, sizeof(buf), "data", t) ? 1 : 0;
r |= get_param_value(buf, sizeof(buf), "file", t) ? 2 : 0;
switch (r) {
case 0:
buf[0] = '\0';
/* fallthrough for default behavior */
case 1:
has_header = false;
break;
case 2:
has_header = true;
break;
default:
fprintf(stderr, "acpitable: both data and file are specified\n");
return -1;
}
if (!acpi_tables) {
allen = sizeof(uint16_t);
acpi_tables = g_malloc0(allen);
} else {
allen = acpi_tables_len;
}
start = allen;
acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
/* now read in the data files, reallocating buffer as needed */
for (f = strtok(buf, ":"); f; f = strtok(NULL, ":")) {
int fd = open(f, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "can't open file %s: %s\n", f, strerror(errno));
return -1;
}
for (;;) {
char data[8192];
r = read(fd, data, sizeof(data));
if (r == 0) {
break;
} else if (r > 0) {
acpi_tables = g_realloc(acpi_tables, allen + r);
memcpy(acpi_tables + allen, data, r);
allen += r;
} else if (errno != EINTR) {
fprintf(stderr, "can't read file %s: %s\n",
f, strerror(errno));
close(fd);
return -1;
}
}
close(fd);
}
/* now fill in the header fields */
f = acpi_tables + start; /* start of the table */
changed = 0;
/* copy the header to temp place to align the fields */
memcpy(&hdr, has_header ? f : dfl_hdr, ACPI_TABLE_HDR_SIZE);
/* length of the table minus our prefix */
len = allen - start - ACPI_TABLE_PFX_SIZE;
hdr._length = cpu_to_le16(len);
if (get_param_value(buf, sizeof(buf), "sig", t)) {
strzcpy(hdr.sig, buf, sizeof(hdr.sig));
++changed;
}
/* length of the table including header, in bytes */
if (has_header) {
/* check if actual length is correct */
val = le32_to_cpu(hdr.length);
if (val != len) {
fprintf(stderr,
"warning: acpitable has wrong length,"
" header says %lu, actual size %zu bytes\n",
val, len);
++changed;
}
}
/* we may avoid putting length here if has_header is true */
hdr.length = cpu_to_le32(len);
if (get_param_value(buf, sizeof(buf), "rev", t)) {
val = strtoul(buf, &p, 0);
if (val > 255 || *p) {
fprintf(stderr, "acpitable: \"rev=%s\" is invalid\n", buf);
return -1;
}
hdr.revision = (uint8_t)val;
++changed;
}
if (get_param_value(buf, sizeof(buf), "oem_id", t)) {
strzcpy(hdr.oem_id, buf, sizeof(hdr.oem_id));
++changed;
}
if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) {
strzcpy(hdr.oem_table_id, buf, sizeof(hdr.oem_table_id));
++changed;
}
if (get_param_value(buf, sizeof(buf), "oem_rev", t)) {
val = strtol(buf, &p, 0);
if (*p) {
fprintf(stderr, "acpitable: \"oem_rev=%s\" is invalid\n", buf);
return -1;
}
hdr.oem_revision = cpu_to_le32(val);
++changed;
}
if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) {
strzcpy(hdr.asl_compiler_id, buf, sizeof(hdr.asl_compiler_id));
++changed;
}
if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) {
val = strtol(buf, &p, 0);
if (*p) {
fprintf(stderr, "acpitable: \"%s=%s\" is invalid\n",
"asl_compiler_rev", buf);
return -1;
}
hdr.asl_compiler_revision = cpu_to_le32(val);
++changed;
}
if (!has_header && !changed) {
fprintf(stderr, "warning: acpitable: no table headers are specified\n");
}
/* now calculate checksum of the table, complete with the header */
/* we may as well leave checksum intact if has_header is true */
/* alternatively there may be a way to set cksum to a given value */
hdr.checksum = 0; /* for checksum calculation */
/* put header back */
memcpy(f, &hdr, sizeof(hdr));
if (changed || !has_header || 1) {
((struct acpi_table_header *)f)->checksum =
acpi_checksum((uint8_t *)f + ACPI_TABLE_PFX_SIZE, len);
}
/* increase number of tables */
(*(uint16_t *)acpi_tables) =
cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);
acpi_tables_len = allen;
return 0;
}
GPResult
gpiProcessConnect(
GPConnection * connection,
GPIOperation * operation,
const char * input
)
{
char buffer[512];
char check[33];
char uniquenick[GP_UNIQUENICK_LEN];
GPIConnectData * data;
GPIConnection * iconnection = (GPIConnection*)*connection;
GPICallback callback;
GPIProfile * profile;
char userBuffer[GP_NICK_LEN + GP_EMAIL_LEN];
char partnerBuffer[11];
char * user;
// Check for an error.
//////////////////////
if(gpiCheckForError(connection, input, GPIFalse))
{
// Is this a deleted profile?
/////////////////////////////
if((iconnection->errorCode == GP_LOGIN_PROFILE_DELETED) && iconnection->profileid)
{
// Remove this profile object.
//////////////////////////////
gpiRemoveProfileByID(connection, iconnection->profileid);
// If we have the profileid/userid cached, lose them.
/////////////////////////////////////////////////////
iconnection->userid = 0;
iconnection->profileid = 0;
}
// Check for creating an existing profile.
//////////////////////////////////////////
else if(iconnection->errorCode == GP_NEWUSER_BAD_NICK)
{
// Store the pid.
/////////////////
if(gpiValueForKey(input, "\\pid\\", buffer, sizeof(buffer)))
iconnection->profileid = atoi(buffer);
}
// Call the callbacks.
//////////////////////
CallbackFatalError(connection, GP_SERVER_ERROR, iconnection->errorCode, iconnection->errorString);
}
// Get a pointer to the data.
/////////////////////////////
data = (GPIConnectData*)operation->data;
switch(operation->state)
{
case GPI_CONNECTING:
// This should be \lc\1.
////////////////////////
if(strncmp(input, "\\lc\\1", 5) != 0)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the server challenge.
////////////////////////////
if(!gpiValueForKey(input, "\\challenge\\", data->serverChallenge, sizeof(data->serverChallenge)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Check if this is a new user.
///////////////////////////////
if(data->newuser)
{
// Send a new user message.
///////////////////////////
CHECK_RESULT(gpiSendNewuser(connection, data));
// Update the operation's state.
////////////////////////////////
operation->state = GPI_REQUESTING;
}
else
{
// Send a login message.
////////////////////////
CHECK_RESULT(gpiSendLogin(connection, data));
// Update the operation's state.
////////////////////////////////
operation->state = GPI_LOGIN;
}
break;
case GPI_REQUESTING:
// This should be \nur\.
////////////////////////
if(strncmp(input, "\\nur\\", 5) != 0)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the userid.
//////////////////
if(!gpiValueForKey(input, "\\userid\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
iconnection->userid = atoi(buffer);
// Get the profileid.
/////////////////////
if(!gpiValueForKey(input, "\\profileid\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
iconnection->profileid = atoi(buffer);
// Send a login request.
////////////////////////
CHECK_RESULT(gpiSendLogin(connection, data));
// Update the operation's state.
////////////////////////////////
operation->state = GPI_LOGIN;
break;
case GPI_LOGIN:
// This should be \lc\2.
////////////////////////
if(strncmp(input, "\\lc\\2", 5) != 0)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server.");
// Get the sesskey.
///////////////////
if(!gpiValueForKey(input, "\\sesskey\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
iconnection->sessKey = atoi(buffer);
// Get the userid.
//////////////////
if(!gpiValueForKey(input, "\\userid\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
iconnection->userid = atoi(buffer);
// Get the profileid.
/////////////////////
if(!gpiValueForKey(input, "\\profileid\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
iconnection->profileid = atoi(buffer);
// Get the uniquenick.
//////////////////////
if(!gpiValueForKey(input, "\\uniquenick\\", uniquenick, sizeof(uniquenick)))
uniquenick[0] = '\0';
// Get the loginticket.
//////////////////////
if(!gpiValueForKey(input, "\\lt\\", iconnection->loginTicket, sizeof(iconnection->loginTicket)))
iconnection->loginTicket[0] = '\0';
// Construct the user.
//////////////////////
if(iconnection->partnerID != GP_PARTNERID_GAMESPY)
{
sprintf(partnerBuffer, "%d@", iconnection->partnerID);
}
else
{
// GS ID's do not stash the partner ID in the auth challenge to support legacy clients.
strcpy(partnerBuffer, "");
}
if(data->authtoken[0])
user = data->authtoken;
else if(iconnection->uniquenick[0])
{
sprintf(userBuffer, "%s%s", partnerBuffer, iconnection->uniquenick);
user = userBuffer;
}
else
{
sprintf(userBuffer, "%s%s@%s", partnerBuffer, iconnection->nick, iconnection->email);
user = userBuffer;
}
// Construct the check.
///////////////////////
sprintf(buffer, "%s%s%s%s%s%s",
data->passwordHash,
" ",
user,
data->serverChallenge,
data->userChallenge,
data->passwordHash);
MD5Digest((unsigned char *)buffer, strlen(buffer), check);
// Get the proof.
/////////////////
if(!gpiValueForKey(input, "\\proof\\", buffer, sizeof(buffer)))
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexepected data was received from the server.");
// Check the server authentication.
///////////////////////////////////
if(memcmp(check, buffer, 32) != 0)
CallbackFatalError(connection, GP_NETWORK_ERROR, GP_LOGIN_SERVER_AUTH_FAILED, "Could not authenticate server.");
// Add the local profile to the list.
/////////////////////////////////////
if(iconnection->infoCaching)
{
profile = gpiProfileListAdd(connection, iconnection->profileid);
profile->profileId = iconnection->profileid;
profile->userId = iconnection->userid;
}
// Set the connect state.
/////////////////////////
iconnection->connectState = GPI_CONNECTED;
// Call the connect-response callback.
//////////////////////////////////////
callback = operation->callback;
if(callback.callback != NULL)
{
GPConnectResponseArg * arg;
arg = (GPConnectResponseArg *)gsimalloc(sizeof(GPConnectResponseArg));
if(arg == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
memset(arg, 0, sizeof(GPConnectResponseArg));
arg->profile = (GPProfile)iconnection->profileid;
arg->result = GP_NO_ERROR;
#ifndef GSI_UNICODE
strzcpy(arg->uniquenick, uniquenick, GP_UNIQUENICK_LEN);
#else
UTF8ToUCS2StringLen(uniquenick, arg->uniquenick, GP_UNIQUENICK_LEN);
#endif
CHECK_RESULT(gpiAddCallback(connection, callback, arg, operation, 0));
}
// This operation is complete.
//////////////////////////////
gpiRemoveOperation(connection, operation);
// Get the local profile's info.
////////////////////////////////
#if 0
gpiAddOperation(connection, GPI_GET_INFO, NULL, &operation, GP_NON_BLOCKING, NULL, NULL);
gpiSendGetInfo(connection, iconnection->profileid, operation->id);
#endif
#ifdef _PS3
// We just connected, so setup buddy sync && start NP init
// For future, we can limit syncs by setting flags to turn on/off here
//////////////////////////////////////////////////////////////////////
iconnection->npPerformBuddySync = gsi_true;
iconnection->npPerformBlockSync = gsi_true;
iconnection->loginTime = current_time();
if (!iconnection->npInitialized)
gpiInitializeNpBasic(connection);
#endif
break;
default:
break;
}
return GP_NO_ERROR;
}
GPResult
gpiConnect(
GPConnection * connection,
const char nick[GP_NICK_LEN],
const char uniquenick[GP_UNIQUENICK_LEN],
const char email[GP_EMAIL_LEN],
const char password[GP_PASSWORD_LEN],
const char authtoken[GP_AUTHTOKEN_LEN],
const char partnerchallenge[GP_PARTNERCHALLENGE_LEN],
const char cdkey[GP_CDKEY_LEN],
GPEnum firewall,
GPIBool newuser,
GPEnum blocking,
GPCallback callback,
void * param
)
{
GPIConnectData * data;
GPIOperation * operation;
GPIConnection * iconnection = (GPIConnection*)*connection;
GPResult result;
// Reset if this connection was already used.
/////////////////////////////////////////////
if(iconnection->connectState == GPI_DISCONNECTED)
CHECK_RESULT(gpiReset(connection));
// Error check.
///////////////
if(iconnection->connectState != GPI_NOT_CONNECTED)
Error(connection, GP_PARAMETER_ERROR, "Invalid connection.");
// Get the firewall setting.
////////////////////////////
#if defined(GS_WIRELESS_DEVICE)
GSI_UNUSED(firewall);
iconnection->firewall = GPITrue;
#else
switch(firewall)
{
case GP_FIREWALL:
iconnection->firewall = GPITrue;
break;
case GP_NO_FIREWALL:
iconnection->firewall = GPIFalse;
break;
default:
Error(connection, GP_PARAMETER_ERROR, "Invalid firewall.");
}
#endif
// Get the nick, uniquenick, email, and password.
/////////////////////////////////////////////////
strzcpy(iconnection->nick, nick, GP_NICK_LEN);
strzcpy(iconnection->uniquenick, uniquenick, GP_UNIQUENICK_LEN);
strzcpy(iconnection->email, email, GP_EMAIL_LEN);
strzcpy(iconnection->password, password, GP_PASSWORD_LEN);
#ifdef GSI_UNICODE
// Create the _W version in addition
UTF8ToUCS2StringLen(iconnection->nick, iconnection->nick_W, GP_NICK_LEN);
UTF8ToUCS2StringLen(iconnection->uniquenick, iconnection->uniquenick_W, GP_UNIQUENICK_LEN);
UTF8ToUCS2StringLen(iconnection->email, iconnection->email_W, GP_EMAIL_LEN);
UTF8ToUCS2StringLen(iconnection->password, iconnection->password_W, GP_PASSWORD_LEN);
#endif
// Lowercase the email.
///////////////////////
_strlwr(iconnection->email);
#ifdef GSI_UNICODE
// Update the UCS2 version (emails are ASCII anyhow so lowercasing didn't data)
AsciiToUCS2String(iconnection->email, iconnection->email_W);
#endif
// Create a connect operation data struct.
//////////////////////////////////////////
data = (GPIConnectData *)gsimalloc(sizeof(GPIConnectData));
if(data == NULL)
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
memset(data, 0, sizeof(GPIConnectData));
// Check for new user.
//////////////////////
data->newuser = newuser;
// Store pre-auth data.
///////////////////////
if(authtoken[0] && partnerchallenge[0])
{
strzcpy(data->authtoken, authtoken, GP_AUTHTOKEN_LEN);
strzcpy(data->partnerchallenge, partnerchallenge, GP_PARTNERCHALLENGE_LEN);
}
// Store cdkey if we have one.
//////////////////////////////
if(cdkey)
strzcpy(data->cdkey, cdkey, GP_CDKEY_LEN);
// Add the operation to the list.
/////////////////////////////////
CHECK_RESULT(gpiAddOperation(connection, GPI_CONNECT, data, &operation, blocking, callback, param));
// Start it.
////////////
result = gpiStartConnect(connection, operation);
if(result != GP_NO_ERROR)
{
operation->result = result;
gpiFailedOpCallback(connection, operation);
gpiDisconnect(connection, GPIFalse);
return result;
}
// Process it if blocking.
//////////////////////////
if(operation->blocking)
CHECK_RESULT(gpiProcess(connection, operation->id));
return GP_NO_ERROR;
}
/*
* This procedure implements the messages passed by the window
* manager for default processing on behalf of the window.
*/
LRESULT WINAPI
DefWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
RECT rc;
DWORD dwStyle;
HBRUSH hbr;
HPEN hpen, holdpen;
PAINTSTRUCT ps;
POINT curpt;
int x, y;
HWND wp;
HWND oldActive;
COLORREF crCaption;
LPNCCALCSIZE_PARAMS lpnc;
CHAR szTitle[64];
static POINT startpt;
switch(msg) {
case WM_NCCALCSIZE:
/* calculate client rect from passed window rect in rgrc[0]*/
lpnc = (LPNCCALCSIZE_PARAMS)lParam;
dwStyle = GetWindowLong(hwnd, GWL_STYLE);
if(dwStyle & WS_BORDER) {
if((dwStyle & WS_CAPTION) == WS_CAPTION) {
InflateRect(&lpnc->rgrc[0],
-mwSYSMETRICS_CXFRAME,
-mwSYSMETRICS_CYFRAME);
lpnc->rgrc[0].top += mwSYSMETRICS_CYCAPTION + 1;
} else
InflateRect(&lpnc->rgrc[0], -1, -1);
}
break;
case WM_NCPAINT:
/* repaint all non-client area*/
dwStyle = GetWindowLong(hwnd, GWL_STYLE);
if(dwStyle & WS_BORDER) {
hdc = GetWindowDC(hwnd);
GetWindowRect(hwnd, &rc);
if((dwStyle & WS_CAPTION) == WS_CAPTION) {
/* draw 2-line 3d border around window*/
Draw3dOutset(hdc, rc.left, rc.top,
rc.right-rc.left, rc.bottom-rc.top);
InflateRect(&rc, -2, -2);
/* draw 1-line inset inside border*/
hpen = CreatePen(PS_SOLID, 1,
GetSysColor(COLOR_BTNFACE));
holdpen = SelectObject(hdc, hpen);
SelectObject(hdc, GetStockObject(NULL_BRUSH));
Rectangle(hdc, rc.left, rc.top, rc.right,
rc.bottom);
InflateRect(&rc, -1, -1);
/* fill caption*/
rc.bottom = rc.top + mwSYSMETRICS_CYCAPTION;
crCaption = GetActiveWindow()==hwnd?
GetSysColor(COLOR_ACTIVECAPTION):
GetSysColor(COLOR_INACTIVECAPTION);
hbr = CreateSolidBrush(crCaption);
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
/* draw 1 line under caption*/
MoveToEx(hdc, rc.left, rc.bottom, NULL);
LineTo(hdc, rc.right, rc.bottom);
DeleteObject(SelectObject(hdc, holdpen));
/* draw caption text*/
if(GetWindowText(hwnd, szTitle,
sizeof(szTitle))) {
SetBkMode(hdc, TRANSPARENT);
/* set background color even though
* transparent in case GdArea is used
* to draw text which compares
* gr_foreground != gr_background
* when transparent...
*/
SetBkColor(hdc, crCaption);
SetTextColor(hdc,
GetActiveWindow()==hwnd?
GetSysColor(COLOR_CAPTIONTEXT):
GetSysColor(COLOR_INACTIVECAPTIONTEXT));
SelectObject(hdc,
GetStockObject(DEFAULT_GUI_FONT));
GetWindowRect(hwnd, &rc);
TextOut(hdc, rc.left+4, rc.top+2,
szTitle, strlen(szTitle));
}
/* draw close box*/
GetCloseBoxRect(hwnd, &rc);
/*DrawDIB(hdc, rc.right-XSIZE_CLOSEBOX-3,
rc.top+3, &image_close4);*/
Draw3dBox(hdc, rc.left, rc.top,
rc.right-rc.left, rc.bottom-rc.top,
GetSysColor(COLOR_BTNHIGHLIGHT),
GetSysColor(COLOR_WINDOWFRAME));
InflateRect(&rc, -1, -1);
hbr = CreateSolidBrush(
GetSysColor(COLOR_BTNFACE));
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
InflateRect(&rc, -1, -1);
MoveToEx(hdc, rc.left, rc.top, NULL);
LineTo(hdc, rc.right-1, rc.bottom-1);
MoveToEx(hdc, rc.left, rc.bottom-1, NULL);
LineTo(hdc, rc.right-1, rc.top);
} else {
SelectObject(hdc, GetStockObject(NULL_BRUSH));
Rectangle(hdc, rc.left, rc.top, rc.right,
rc.bottom);
}
ReleaseDC(hwnd, hdc);
}
break;
case WM_NCHITTEST:
/* if system is dragging a window, always return caption*/
if(dragwp)
return HTCAPTION;
/* Determine what part of the window the mouse is over*/
POINTSTOPOINT(curpt, lParam);
if(PtInRect(&hwnd->clirect, curpt))
return HTCLIENT;
if(PtInRect(&hwnd->vscroll.rc, curpt))
return HTVSCROLL;
if(PtInRect(&hwnd->hscroll.rc, curpt))
return HTHSCROLL;
dwStyle = GetWindowLong(hwnd, GWL_STYLE);
if((dwStyle & WS_CAPTION) == WS_CAPTION) {
GetCloseBoxRect(hwnd, &rc);
if(PtInRect(&rc, curpt))
return HTCLOSE;
GetWindowRect(hwnd, &rc);
InflateRect(&rc, -2, -2);
rc.bottom = rc.top + mwSYSMETRICS_CYCAPTION;
if(PtInRect(&rc, curpt))
return HTCAPTION;
GetWindowRect(hwnd, &rc);
InflateRect(&rc, -2, -2);
rc.top += mwSYSMETRICS_CYCAPTION;
if(PtInRect(&rc, curpt))
return HTCLIENT;
return HTBORDER;
}
return HTNOWHERE;
case WM_NCLBUTTONDOWN:
/* Handle default actions for mouse down on window*/
if(wParam == HTCLOSE) {
SendMessage(hwnd, WM_CLOSE, 0, 0L);
break;
}
/* set focus on mouse down, repaint if necessary*/
oldActive = GetActiveWindow();
if(wParam == HTCLIENT || wParam == HTVSCROLL ||
wParam == HTHSCROLL)
/* activate and raise window if in client area*/
/* kaffe port requires this commented out*/
SetForegroundWindow(hwnd);
else {
/* otherwise just change focus window, same z order*/
/* this will activate it's top level parent*/
SetFocus(hwnd);
}
/* repaint captions now because of activation change*/
UpdateWindow(oldActive);
UpdateWindow(hwnd);
if(wParam == HTVSCROLL || wParam == HTHSCROLL) {
MwHandleNCMessageScrollbar(hwnd, msg, wParam, lParam);
break;
}
/* start window drag if in caption area*/
if(wParam == HTCAPTION && hwnd != rootwp) {
POINTSTOPOINT(startpt, lParam);
if(!(GetWindowLong(hwnd, GWL_STYLE) & WS_MAXIMIZE))
dragwp = hwnd;
SetRectEmpty(&lastrc); /* XORMOVE only*/
}
break;
case WM_NCMOUSEMOVE:
if(wParam == HTVSCROLL || wParam == HTHSCROLL) {
MwHandleNCMessageScrollbar(hwnd, msg, wParam, lParam);
break;
}
/* drag window with mousemove after mousedown*/
if(dragwp == hwnd) {
POINTSTOPOINT(curpt, lParam);
x = curpt.x - startpt.x;
y = curpt.y - startpt.y;
if(mwERASEMOVE) {
GetWindowRect(hwnd, &rc);
MoveWindow(hwnd, rc.left+x, rc.top+y,
rc.right-rc.left, rc.bottom-rc.top,
TRUE);
startpt = curpt;
} else
DrawXORFrame(hwnd, x, y, TRUE);
}
break;
case WM_NCLBUTTONUP:
/* stop window drag*/
if(dragwp == hwnd) {
dragwp = NULL;
if(mwERASEMOVE) {
/*
* User stopped moving window, repaint
* windows previously queued for painting.
*/
for(wp=listwp; wp; wp=wp->next)
if(wp->gotPaintMsg == PAINT_DELAYPAINT)
wp->gotPaintMsg = PAINT_NEEDSPAINT;
} else {
POINTSTOPOINT(curpt, lParam);
x = curpt.x - startpt.x;
y = curpt.y - startpt.y;
DrawXORFrame(hwnd, x, y, FALSE);
GetWindowRect(hwnd, &rc);
MoveWindow(hwnd, rc.left+x, rc.top+y,
rc.right-rc.left, rc.bottom-rc.top, TRUE);
}
}
if(wParam == HTVSCROLL || wParam == HTHSCROLL) {
MwHandleNCMessageScrollbar(hwnd, msg, wParam, lParam);
break;
}
break;
case WM_NCLBUTTONDBLCLK:
if(wParam == HTVSCROLL || wParam == HTHSCROLL) {
MwHandleNCMessageScrollbar(hwnd, msg, wParam, lParam);
break;
}
/* maximize/restore processing*/
if(wParam != HTCAPTION)
break;
if((hwnd->style & WS_CAPTION) == WS_CAPTION) {
if(hwnd->style & WS_MAXIMIZE) {
rc = hwnd->restorerc;
MoveWindow(hwnd, rc.left, rc.top,
rc.right-rc.left, rc.bottom-rc.top,
TRUE);
hwnd->style &= ~WS_MAXIMIZE;
} else {
hwnd->restorerc = hwnd->winrect;
GetWindowRect(rootwp, &rc);
MoveWindow(hwnd, -mwSYSMETRICS_CXFRAME,
-mwSYSMETRICS_CYFRAME,
rc.right+2*mwSYSMETRICS_CXFRAME,
rc.bottom+2*mwSYSMETRICS_CYFRAME, TRUE);
hwnd->style |= WS_MAXIMIZE;
}
}
break;
case WM_GETTEXTLENGTH:
/* Get window text length. This routine requires
* knowledge of the internal window structure
*/
return strlen(hwnd->szTitle);
case WM_GETTEXT:
/* Get window text. This routine requires
* knowledge of the internal window structure
*/
return strzcpy((LPSTR)lParam, hwnd->szTitle, wParam);
case WM_SETTEXT:
/* Set window text. This routine requires
* knowledge of the internal window structure.
* Note that setting text doesn't invalidate the window.
*/
strzcpy(hwnd->szTitle, (LPSTR)lParam, sizeof(hwnd->szTitle));
return TRUE;
case WM_CLOSE:
DestroyWindow(hwnd);
if(hwnd == rootwp)
PostQuitMessage(0);
break;
case WM_ERASEBKGND:
/* erase background with class background brush*/
hbr = (HBRUSH)GetClassLong(hwnd, GCL_HBRBACKGROUND);
if(!hbr)
return 0;
/* don't exclude update region*/
hdc = GetDCEx(hwnd, NULL, DCX_DEFAULTCLIP);
FillRect(hdc, NULL, hbr);
ReleaseDC(hwnd, hdc);
return 1;
case WM_PAINT:
/* required to send erasebkgnd for desktop window*/
hdc = BeginPaint(hwnd, &ps);
/* draw desktop wallpaper*/
if(hwnd == rootwp && pImageWallpaper) {
GetWindowRect(hwnd, &rc);
DrawDIB(hdc,
(rc.right-rc.left-pImageWallpaper->width)/2,
(rc.bottom-rc.top-pImageWallpaper->height)/2,
pImageWallpaper);
}
EndPaint(hwnd, &ps);
break;
}
return 0;
}
// This is for legacy up to 5.0(?). Cuz ML added new bytes in the middle of the packet.
void send_full_statmsg_std( Client *client, Character *chr )
{
PKTOUT_11_V1 msg;
msg.msgtype = PKTOUT_11_V1_ID;
if( (client->UOExpansionFlag & AOS) )
{
msg.msglen = ctBEu16(sizeof msg);
msg.moreinfo = 04; // Set to AOS level statbar for full info
}
else
{
unsigned short msglen = offsetof( PKTOUT_11_V1, statcap );
msg.msglen = ctBEu16(msglen);
msg.moreinfo = 01; // Set to oldschool statbar info.
}
msg.serial = chr->serial_ext;
strzcpy( msg.name, chr->name().c_str(), sizeof msg.name );
if (uoclient_general.hits.any)
{
long v = chr->vital(uoclient_general.hits.id).current_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.hits = ctBEu16( static_cast<u16>(v) );
v = chr->vital(uoclient_general.hits.id).maximum_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.max_hits = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.hits = 0;
msg.max_hits = 0;
}
msg.renameable = 0; // (client->chr->can_rename( chr ) ? 0xFF : 0);
//if (chr->race == RACE_ELF)
// msg.gender = static_cast<u8>(chr->gender | FLAG_RACE);
//else
msg.gender = static_cast<u8>(chr->gender);
if (uoclient_general.strength.any)
{
long v = chr->attribute(uoclient_general.strength.id).effective();
if (v > 0xFFFF)
v = 0xFFFF;
msg.str = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.str = 0;
}
if (uoclient_general.dexterity.any)
{
long v = chr->attribute(uoclient_general.dexterity.id).effective();
if (v > 0xFFFF)
v = 0xFFFF;
msg.dex = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.dex = 0;
}
if (uoclient_general.intelligence.any)
{
long v = chr->attribute(uoclient_general.intelligence.id).effective();
if (v > 0xFFFF)
v = 0xFFFF;
msg.intel = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.intel = 0;
}
if (uoclient_general.stamina.any)
{
long v = chr->vital(uoclient_general.stamina.id).current_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.stamina = ctBEu16( static_cast<u16>(v) );
v = chr->vital( uoclient_general.stamina.id ).maximum_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.max_stamina = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.stamina = 0;
msg.max_stamina = 0;
}
if (uoclient_general.mana.any)
{
long v = chr->vital(uoclient_general.mana.id).current_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.mana = ctBEu16( static_cast<u16>(v) );
v = chr->vital(uoclient_general.mana.id).maximum_ones();
if (v > 0xFFFF)
v = 0xFFFF;
msg.max_mana = ctBEu16( static_cast<u16>(v) );
}
else
{
msg.mana = 0;
msg.max_mana = 0;
}
msg.gold = ctBEu32( chr->gold_carried() );
// Adjusted to work with Physical Resist if AOS client, and AOS Resistances enabled.
if( (client->UOExpansionFlag & AOS) && client->aosresist )
msg.AR = (chr->element_resist.physical < 0)?ctBEu16(0x10000+chr->element_resist.physical):ctBEu16(chr->element_resist.physical);
else
msg.AR = ctBEu16( chr->ar() );
msg.weight = ctBEu16( static_cast<u16>(chr->weight()) );
if ( msg.moreinfo >= 4 )
{
msg.statcap = ctBEu16( chr->expanded_statbar.statcap );
msg.followers = chr->expanded_statbar.followers;
msg.followers_max = chr->expanded_statbar.followers_max;
msg.fireresist = (chr->element_resist.fire < 0)?ctBEu16(0x10000+chr->element_resist.fire):ctBEu16(chr->element_resist.fire);
msg.coldresist = (chr->element_resist.cold < 0)?ctBEu16(0x10000+chr->element_resist.cold):ctBEu16(chr->element_resist.cold);
msg.poisonresist = (chr->element_resist.poison < 0)?ctBEu16(0x10000+chr->element_resist.poison):ctBEu16(chr->element_resist.poison);
msg.energyresist = (chr->element_resist.energy < 0)?ctBEu16(0x10000+chr->element_resist.energy):ctBEu16(chr->element_resist.energy);
msg.luck = ctBEu16( chr->expanded_statbar.luck );
msg.damage_min = ctBEu16( chr->min_weapon_damage() );
msg.damage_max = ctBEu16( chr->max_weapon_damage() );
msg.titching = ctBEu32( chr->expanded_statbar.tithing );
}
transmit(client, &msg, cfBEu16(msg.msglen) );
}
CHATBool ciSocketConnect(ciSocket * sock,
const char * serverAddress,
int port)
{
unsigned int ip;
HOSTENT * host;
SOCKADDR_IN address;
int rcode;
#if !defined(INSOCK) && !defined(_NITRO) && !defined(_REVOLUTION)
int keepalive;
#endif
ASSERT_SOCK(sock);
assert(serverAddress != NULL);
assert(port >= 0);
assert(port <= USHRT_MAX);
assert(sock->connectState == ciNotConnected);
// Copy off the address.
////////////////////////
strzcpy(sock->serverAddress, serverAddress, 255);
// Try resolving the string as an IP a.b.c.d number.
////////////////////////////////////////////////////
ip = inet_addr(serverAddress);
if(ip == INADDR_NONE)
{
// Try resolving with DNS.
//////////////////////////
host = gethostbyname((char *)serverAddress);
if(host == NULL)
return CHATFalse;
// Get the ip.
//////////////
ip = *(unsigned int *)host->h_addr_list[0];
}
// Setup the address.
/////////////////////
memset(&address, 0, sizeof(SOCKADDR_IN));
address.sin_family = AF_INET;
address.sin_addr.s_addr = ip;
address.sin_port = htons((unsigned short)port);
// Create the socket.
/////////////////////
sock->sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock->sock == INVALID_SOCKET)
return CHATFalse;
// Enable keep-alive.
/////////////////////
#if !defined(INSOCK) && !defined(_NITRO) && !defined(_REVOLUTION)
keepalive = 1;
rcode = setsockopt(sock->sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive, sizeof(int));
//assert(gsiSocketIsNotError(rcode));
#endif
// Try and connect.
///////////////////
rcode = connect(sock->sock, (SOCKADDR *)&address, sizeof(SOCKADDR_IN));
if(gsiSocketIsError(rcode))
{
closesocket(sock->sock);
return CHATFalse;
}
// We're connected.
///////////////////
sock->connectState = ciConnected;
return CHATTrue;
}