//----------------------------------
//
// your solution to this question should look something like this
//
// if you run userprog3.dlx.obj 2, it should output
//
// A0
// B0
// A1
// A2
// A3
// A4
// A5
// A6
// B1
// A7
// A8
// A9
// B2
// A10
// B3
// A11
// B4
// A12
// B5
// A13
// B6
// A14
// B7
// A15
// B8
// A16
// B9
// A17
// B10
// A18
// B11
// A19
// B12
// A20
// B13
// A21
// B14
// A22
// B15
// A23
// B16
// A24
// B17
// A25
// B18
// A26
// B19
// A27
// B20
// A28
// B21
// A29
// B22
// A0
// B23
// A1
// B24
// A2
// B25
// A3
// B26
// A4
// B27
// A5
// B28
// A6
// B29
// A7
// B0
// A8
// B1
// A9
// B2
// A10
// B3
// A11
// B4
// A12
// B5
// A13
// B6
// A14
// B7
// A15
// B8
// A16
// B9
// A17
// B10
// A18
// B11
// A19
// B12
// A20
// B13
// A21
// B14
// A22
// B15
// A23
// B16
// A24
// B17
// A25
// B18
// A26
// B19
// A27
// B20
// A28
// B21
// A29
// B22
// B23
// B24
// B25
// B26
// B27
// B28
// B29
// make sure you understand the scheduling algorithm works b4 you strart hacking
//
// You are free to modify this file (and other userprogs) to test your solution
// We will not use the same files to test your code.
//
//----------------------------------------------------------------------------
main (int argc, char *argv[])
{
int number, i,j,offset;
uint32 handle;
sem_t semaphore;
char num_str[10], semaphore_str[10];
Printf("\n\n**** argc = %d\n\n\n", argc);
switch(argc)
{
case 2:
Printf("timer = %d\n", TimerGet());
number = dstrtol(argv[1], NULL, 10);
Printf("Setting number = %d\n", number);
for(i=0; i<50; i++)
Printf("1");
Printf("timer = %d\n", TimerGet());
semaphore = sem_create(1);
ditoa(semaphore, semaphore_str); //Convert the semaphore to a string
Printf("timer = %d\n", TimerGet());
for(i=0; i<number; i++)
{
ditoa(i, num_str);
process_create(i,0,"userprog4.dlx.obj", num_str,semaphore_str,
NULL);
}
Printf("timer = %d\n", TimerGet());
yield();
break;
case 3:
offset = dstrtol(argv[1], NULL, 10); //Get semaphore
semaphore = dstrtol(argv[2], NULL, 10); //Get semaphore
for(i=0;i<30;i++)
{
for(j=0;j<50000;j++);
Printf("%c%d\n",'A'+offset,i);
}
for(i=0;i<30;i++)
{
sem_wait(semaphore);
for(j=0;j<50000;j++);
Printf("%c%d\n",'A'+offset,i);
sem_signal(semaphore);
}
break;
default:
Printf("Usage: ");
Printf(argv[0]);
Printf(" number\n");
Printf("argc = %d\n", argc);
exit();
}
}
static INT_PTR CALLBACK gg_confoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
DWORD num;
switch (msg) {
case WM_INITDIALOG:
gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)TranslateT("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_SETCURSEL, gg->getWord(GG_KEY_GC_POLICY_TOTAL, GG_KEYDEF_GC_POLICY_TOTAL), 0);
if (num = gg->getWord(GG_KEY_GC_COUNT_TOTAL, GG_KEYDEF_GC_COUNT_TOTAL))
SetDlgItemTextA(hwndDlg, IDC_GC_COUNT_TOTAL, ditoa(num));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)TranslateT("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_SETCURSEL, gg->getWord(GG_KEY_GC_POLICY_UNKNOWN, GG_KEYDEF_GC_POLICY_UNKNOWN), 0);
if (num = gg->getWord(GG_KEY_GC_COUNT_UNKNOWN, GG_KEYDEF_GC_COUNT_UNKNOWN))
SetDlgItemTextA(hwndDlg, IDC_GC_COUNT_UNKNOWN, ditoa(num));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)TranslateT("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)TranslateT("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_SETCURSEL, gg->getWord(GG_KEY_GC_POLICY_DEFAULT, GG_KEYDEF_GC_POLICY_DEFAULT), 0);
break;
case WM_COMMAND:
if ((LOWORD(wParam) == IDC_GC_COUNT_TOTAL || LOWORD(wParam) == IDC_GC_COUNT_UNKNOWN)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case WM_NOTIFY:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
char str[128];
// Write groupchat policy
gg->setWord(GG_KEY_GC_POLICY_TOTAL, (WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_GETCURSEL, 0, 0));
gg->setWord(GG_KEY_GC_POLICY_UNKNOWN, (WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_GETCURSEL, 0, 0));
gg->setWord(GG_KEY_GC_POLICY_DEFAULT, (WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_GETCURSEL, 0, 0));
GetDlgItemTextA(hwndDlg, IDC_GC_COUNT_TOTAL, str, _countof(str));
gg->setWord(GG_KEY_GC_COUNT_TOTAL, (WORD)atoi(str));
GetDlgItemTextA(hwndDlg, IDC_GC_COUNT_UNKNOWN, str, _countof(str));
gg->setWord(GG_KEY_GC_COUNT_UNKNOWN, (WORD)atoi(str));
}
break;
}
return FALSE;
}
void main (int argc, char *argv[])
{
int num_hello_world = 0; // Used to store number of processes to create
int i; // Loop index variable
int child_pid;
sem_t s_procs_completed; // Semaphore used to wait until all spawned processes have completed
char s_procs_completed_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
if (argc != 2) {
Printf("Usage: %s <number of hello world processes to create>\n", argv[0]);
Exit();
}
// Convert string from ascii command line argument to integer number
num_hello_world = dstrtol(argv[1], NULL, 10); // the "10" means base 10
Printf("makeprocs (%d): Creating %d hello_world processes\n", getpid(), num_hello_world);
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete.
if ((s_procs_completed = sem_create(-(num_hello_world-1))) == SYNC_FAIL) {
Printf("makeprocs (%d): Bad sem_create\n", getpid());
Exit();
}
// Setup the command-line arguments for the new processes. We're going to
// pass the handles to the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(s_procs_completed, s_procs_completed_str);
// Create Hello World processes
/* Printf("-------------------------------------------------------------------------------------\n");
Printf("makeprocs (%d): Creating %d hello world's in a row, but only one runs at a time\n", getpid(), num_hello_world);
for(i=0; i<num_hello_world; i++) {
Printf("makeprocs (%d): Creating hello world #%d\n", getpid(), i);
process_create(HELLO_WORLD, s_procs_completed_str, NULL);
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
}
*/
//---------------------------------------this section for testing process_fork()--------------------------------------------------
printf("the main program process ID is %d\n",(int)getpid());
child_pid=process_fork();
if(child_pid!=0){
Printf ("this is the parent process with id %d\n",(int)getpid());
Printf ("the child's process ID is %d\n",child_pid);
}else {
Printf ("this is the child process,with id %d\n",(int)getpid());
}
Printf("makeprocs (%d): exiting main process.\n", getpid());
Printf("-------------------------------------------------------------------------------------\n");
}
HANDLE GGPROTO::SearchByName(const PROTOCHAR *nick, const PROTOCHAR *firstName, const PROTOCHAR *lastName)
{
gg_pubdir50_t req;
unsigned long crc;
char data[512] = "\0";
// Check if connected and if there's a search data
if (!isonline())
return 0;
if (!nick && !firstName && !lastName)
return 0;
if (!(req = gg_pubdir50_new(GG_PUBDIR50_SEARCH)))
{
#ifdef DEBUGMODE
debugLogA("SearchByName(): ForkThread 12 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HANDLE)1;
}
// Add nick,firstName,lastName and search it
if (nick)
{
char *nick_utf8 = mir_utf8encodeT(nick);
gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, nick_utf8);
strncat(data, nick_utf8, sizeof(data) - strlen(data));
mir_free(nick_utf8);
}
strncat(data, ".", sizeof(data) - strlen(data));
if (firstName)
{
char *firstName_utf8 = mir_utf8encodeT(firstName);
gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, firstName_utf8);
strncat(data, firstName_utf8, sizeof(data) - strlen(data));
mir_free(firstName_utf8);
}
strncat(data, ".", sizeof(data) - strlen(data));
if (lastName)
{
char *lastName_utf8 = mir_utf8encodeT(lastName);
gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, lastName_utf8);
strncat(data, lastName_utf8, sizeof(data) - strlen(data));
mir_free(lastName_utf8);
}
strncat(data, ".", sizeof(data) - strlen(data));
// Count crc & check if the data was equal if yes do same search with shift
crc = crc_get(data);
if (crc == last_crc && next_uin)
gg_pubdir50_add(req, GG_PUBDIR50_START, ditoa(next_uin));
else
last_crc = crc;
gg_pubdir50_seq_set(req, GG_SEQ_SEARCH);
gg_EnterCriticalSection(&sess_mutex, "SearchByName", 51, "sess_mutex", 1);
if (!gg_pubdir50(sess, req))
{
gg_LeaveCriticalSection(&sess_mutex, "SearchByName", 51, 1, "sess_mutex", 1);
#ifdef DEBUGMODE
debugLogA("SearchByName(): ForkThread 13 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HANDLE)1;
}
gg_LeaveCriticalSection(&sess_mutex, "SearchByName", 51, 2, "sess_mutex", 1);
debugLogA("SearchByName(): Seq %d.", req->seq);
gg_pubdir50_free(req);
return (HANDLE)1;
}
int GGPROTO::GetInfo(HANDLE hContact, int infoType)
{
gg_pubdir50_t req;
// Custom contact info
if (hContact)
{
if (!(req = gg_pubdir50_new(GG_PUBDIR50_SEARCH)))
{
#ifdef DEBUGMODE
debugLogA("GetInfo(): ForkThread 6 GGPROTO::cmdgetinfothread");
#endif
ForkThread(&GGPROTO::cmdgetinfothread, hContact);
return 1;
}
// Add uin and search it
gg_pubdir50_add(req, GG_PUBDIR50_UIN, ditoa((uin_t)getDword(hContact, GG_KEY_UIN, 0)));
gg_pubdir50_seq_set(req, GG_SEQ_INFO);
debugLogA("GetInfo(): Requesting user info.", req->seq);
if (isonline())
{
gg_EnterCriticalSection(&sess_mutex, "GetInfo", 48, "sess_mutex", 1);
if (!gg_pubdir50(sess, req))
{
gg_LeaveCriticalSection(&sess_mutex, "GetInfo", 48, 1, "sess_mutex", 1);
#ifdef DEBUGMODE
debugLogA("GetInfo(): ForkThread 7 GGPROTO::cmdgetinfothread");
#endif
ForkThread(&GGPROTO::cmdgetinfothread, hContact);
return 1;
}
gg_LeaveCriticalSection(&sess_mutex, "GetInfo", 48, 2, "sess_mutex", 1);
}
}
// Own contact info
else
{
if (!(req = gg_pubdir50_new(GG_PUBDIR50_READ)))
{
#ifdef DEBUGMODE
debugLogA("GetInfo(): ForkThread 8 GGPROTO::cmdgetinfothread");
#endif
ForkThread(&GGPROTO::cmdgetinfothread, hContact);
return 1;
}
// Add seq
gg_pubdir50_seq_set(req, GG_SEQ_CHINFO);
debugLogA("GetInfo(): Requesting owner info.", req->seq);
if (isonline())
{
gg_EnterCriticalSection(&sess_mutex, "GetInfo", 49, "sess_mutex", 1);
if (!gg_pubdir50(sess, req))
{
gg_LeaveCriticalSection(&sess_mutex, "GetInfo", 49, 1, "sess_mutex", 1);
#ifdef DEBUGMODE
debugLogA("GetInfo(): ForkThread 9 GGPROTO::cmdgetinfothread");
#endif
ForkThread(&GGPROTO::cmdgetinfothread, hContact);
return 1;
}
gg_LeaveCriticalSection(&sess_mutex, "GetInfo", 49, 2, "sess_mutex", 1);
}
}
debugLogA("GetInfo(): Seq %d.", req->seq);
gg_pubdir50_free(req);
return 1;
}
//----------------------------------------------------------------------
//
// main
//
// This routine is called when the OS starts up. It allocates a
// PCB for the first process - the one corresponding to the initial
// thread of execution. Note that the stack pointer is already
// set correctly by _osinit (assembly language code) to point
// to the stack for the 0th process. This stack isn't very big,
// though, so it should be replaced by the system stack of the
// currently running process.
//
//----------------------------------------------------------------------
main (int argc, char *argv[])
{
int i, j;
int n;
char buf[120];
char *userprog = (char *)0;
static PCB temppcb;
uint32 addr;
extern void SysprocCreateProcesses ();
char *param[12]={NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL};
int base;
debugstr[0] = '\0';
MyFuncRetZero();
printf ("Got %d arguments.\n", argc);
printf ("Available memory: 0x%x -> 0x%x.\n", lastosaddress,
MemoryGetSize ());
printf ("Argument count is %d.\n", argc);
for (i = 0; i < argc; i++) {
printf ("Argument %d is %s.\n", i, argv[i]);
}
// *((int *)0xfff00100) = 't';
FsModuleInit ();
for (i = 0; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'D':
dstrcpy (debugstr, argv[++i]);
break;
case 'i':
n = dstrtol (argv[++i], (void *)0, 0);
ditoa (n, buf);
printf ("Converted %s to %d=%s\n", argv[i], n, buf);
break;
case 'f':
{
int start, codeS, codeL, dataS, dataL, fd, j;
int addr = 0;
static unsigned char buf[200];
fd = ProcessGetCodeInfo (argv[++i], &start, &codeS, &codeL, &dataS,
&dataL);
printf ("File %s -> start=0x%08x\n", argv[i], start);
printf ("File %s -> code @ 0x%08x (size=0x%08x)\n", argv[i], codeS,
codeL);
printf ("File %s -> data @ 0x%08x (size=0x%08x)\n", argv[i], dataS,
dataL);
while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0)
{
for (j = 0; j < n; j += 4)
{
printf ("%08x: %02x%02x%02x%02x\n", addr + j - n, buf[j], buf[j+1],
buf[j+2], buf[j+3]);
}
}
close (fd);
break;
}
case 'u':
userprog = argv[++i];
base = i;
break;
default:
printf ("Option %s not recognized.\n", argv[i]);
break;
}
if(userprog)
break;
}
}
dbprintf ('i', "About to initialize queues.\n");
QueueModuleInit ();
dbprintf ('i', "After initializing queues.\n");
MemoryModuleInit ();
dbprintf ('i', "After initializing memory.\n");
ProcessModuleInit ();
dbprintf ('i', "After initializing processes.\n");
ShareModuleInit ();
dbprintf ('i', "After initializing shared memory.\n");
SynchModuleInit ();
dbprintf ('i', "After initializing synchronization tools.\n");
KbdModuleInit ();
dbprintf ('i', "After initializing keyboard.\n");
for (i = 0; i < 100; i++) {
buf[i] = 'a';
}
i = FsOpen ("vm", FS_MODE_WRITE);
dbprintf ('i', "VM Descriptor is %d\n", i);
FsSeek (i, 0, FS_SEEK_SET);
FsWrite (i, buf, 80);
FsClose (i);
if (userprog != (char *)0) {
for(i=base;i<argc&&i-base<11; i++)
{
param[i-base] = argv[i];
}
process_create(0,0,param[0], param[1], param[2], param[3], param[4],
param[5], param[6], param[7], param[8], param[9],
param[10], param[11]);
// ProcessFork (0, (uint32)"Help Me man!", userprog, 1);
}
SysprocCreateProcesses ();
dbprintf ('i', "Created processes - about to set timer quantum.\n");
TimerSet (processQuantum);
dbprintf ('i', "Set timer quantum to %d, about to run first process.\n",
processQuantum);
intrreturn ();
// Should never be called because the scheduler exits when there
// are no runnable processes left.
exitsim(); // NEVER RETURNS!
}
void main (int argc, char *argv[])
{
int numprocs; // Used to store number of processes to create
int i; // Loop index variable
missile_code mc; // Used as message for mailbox
int num_N2; //numer of N2 injection
int num_H2O; //number of H2O injection
int num_N2_2N; //number of reaction1
int num_H2O_H2_O2; //number of reaction2
int num_N_O2_NO2; //number of reaction3
int number_N2; //number of N2 molecules
int number_H2O; //number of H2O molecules
mbox_t mbox_N2; //N2 mailbox
mbox_t mbox_N; //N mailbox
mbox_t mbox_H2O; //H2O mailbox
mbox_t mbox_H2; //H2 mailbox
mbox_t mbox_O2; //O2 mailbox
mbox_t mbox_NO2; //NO2 mailbox
sem_t s_procs_completed; // Semaphore used to wait until all spawned processes have completed
char mbox_N2_str[10]; // Used as command-line argument to pass mem_handle to new processes
char mbox_N_str[10];
char mbox_H2O_str[10];
char mbox_H2_str[10];
char mbox_O2_str[10];
char mbox_NO2_str[10];
char s_procs_completed_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
if (argc != 3) {
Printf("Usage: ");Printf(argv[0]);Printf("<number of N2 molecules> <number of H2O molecules\n");
Exit();
}
// Convert string from ascii command line argument to integer number
number_N2 = dstrtol(argv[1],NULL,10); //the "10" means base 10
number_H2O = dstrtol(argv[2],NULL,10);
if(number_H2O%2 ==1){
num_H2O = number_H2O;
num_H2O_H2_O2 = (number_H2O-1)/2;
num_N2 = number_N2;
num_N2_2N = number_N2;
if (2*num_N2>num_H2O_H2_O2){ //number of N larger than number of O2
num_N_O2_NO2 = num_H2O_H2_O2;
}
else{
num_N_O2_NO2 = 2*num_N2;
}
}
else{
num_H2O = number_H2O;
num_H2O_H2_O2 =(number_H2O)/2;
num_N2 = number_N2;
num_N2_2N = number_N2;
if (2*num_N2>num_H2O_H2_O2){ //number of N larger than number of O2
num_N_O2_NO2 = num_H2O_H2_O2;
}
else{
num_N_O2_NO2 = 2*num_N2;
}
}
numprocs=num_H2O+num_N2+num_H2O_H2_O2+num_N2_2N+num_N_O2_NO2;
// Allocate space for a mailbox
if ((mbox_N2 = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
if ((mbox_N = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
if ((mbox_O2 = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
if ((mbox_NO2 = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
if ((mbox_H2O = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
if ((mbox_H2 = mbox_create()) == MBOX_FAIL) {
Printf("makeprocs (%d): ERROR: could not allocate mailbox!", getpid());
Exit();
}
// Open mailbox to prevent deallocation
if (mbox_open(mbox_N2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_N2);
Exit();
}
if (mbox_open(mbox_N) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_N);
Exit();
}
if (mbox_open(mbox_H2O) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_H2O);
Exit();
}
if (mbox_open(mbox_H2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_H2);
Exit();
}
if (mbox_open(mbox_O2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_O2);
Exit();
}
if (mbox_open(mbox_NO2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not open mailbox %d!\n", getpid(), mbox_NO2);
Exit();
}
// Put some values in the mc structure to send as a message
mc.numprocs = numprocs;
mc.really_important_char = 'A';
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete. To do this, we will initialize
// the semaphore to (-1) * (number of signals), where "number of signals"
// should be equal to the number of processes we're spawning - 1. Once
// each of the processes has signaled, the semaphore should be back to
// zero and the final sem_wait below will return.
if ((s_procs_completed = sem_create(-(numprocs-1))) == SYNC_FAIL) {
Printf("makeprocs (%d): Bad sem_create\n", getpid());
Exit();
}
// Setup the command-line arguments for the new process. We're going to
// pass the handles to the shared memory page and the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(mbox_N2, mbox_N2_str);
ditoa(mbox_H2O, mbox_H2O_str);
ditoa(mbox_N, mbox_N_str);
ditoa(mbox_H2, mbox_H2_str);
ditoa(mbox_O2, mbox_O2_str);
ditoa(mbox_NO2, mbox_NO2_str);
ditoa(s_procs_completed, s_procs_completed_str);
// Now we can create the processes. Note that you MUST end your call to
// process_create with a NULL argument so that the operating system
// knows how many arguments you are sending.
for(i=0; i<num_N2; i++) {
process_create(FILENAME_TO_RUN_0, 0, 0, mbox_N2_str,s_procs_completed_str, NULL);
// Printf("makeprocs (%d): Process %d created\n", getpid(), i);
}
for(i=0; i<num_H2O; i++) {
process_create(FILENAME_TO_RUN_1, 0, 0, mbox_H2O_str, s_procs_completed_str, NULL);
// Printf("makeprocs (%d): Process %d created\n", getpid(), i);
}
for(i=0; i<num_N2_2N; i++) {
process_create(FILENAME_TO_RUN_2, 0, 0, mbox_N2_str,mbox_N_str, s_procs_completed_str, NULL);
// Printf("makeprocs (%d): Process %d created\n", getpid(), i);
}
for(i=0; i<num_H2O_H2_O2; i++) {
process_create(FILENAME_TO_RUN_3, 0, 0, mbox_H2O_str,mbox_H2_str,mbox_O2_str, s_procs_completed_str, NULL);
// Printf("makeprocs (%d): Process %d created\n", getpid(), i);
}
for(i=0; i<num_N_O2_NO2; i++) {
process_create(FILENAME_TO_RUN_4, 0, 0, mbox_N_str,mbox_O2_str,mbox_NO2_str, s_procs_completed_str, NULL);
// Printf("makeprocs (%d): Process %d created\n", getpid(), i);
}
// And finally, wait until all spawned processes have finished.
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in ", s_procs_completed); Printf(argv[0]); Printf("\n");
Exit();
}
if (mbox_close(mbox_N2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_N2);
Exit();
}
if (mbox_close(mbox_N) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_N);
Exit();
}
if (mbox_close(mbox_O2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_O2);
Exit();
}
if (mbox_close(mbox_NO2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_NO2);
Exit();
}
if (mbox_close(mbox_H2O) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_H2O);
Exit();
}
if (mbox_close(mbox_H2) == MBOX_FAIL) {
Printf("makeprocs (%d): Could not close mailbox %d!\n", getpid(), mbox_H2);
Exit();
}
Printf("makeprocs (%d): All other processes completed, exiting main process.\n", getpid());
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: Account manager options dialog
INT_PTR CALLBACK gg_acc_mgr_guidlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
////////////////////////////////////////////////////////////////////////////////////////////
{
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam)) {
case IDC_CREATEACCOUNT:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, pass, sizeof(pass));
dat.uin = atoi(pass);
GetDlgItemText(hwndDlg, IDC_PASSWORD, pass, sizeof(pass));
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
if(ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemText(hwndDlg, IDC_UIN, "");
// Update password
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_EMAIL, "");
}
}
}
break;
}
case WM_NOTIFY:
{
switch(((LPNMHDR)lParam)->idFrom)
{
case 0:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemText(hwndDlg, IDC_UIN, str, sizeof(str));
uin = atoi(str);
GetDlgItemText(hwndDlg, IDC_PASSWORD, str, sizeof(str));
CallService(MS_DB_CRYPT_ENCODESTRING, sizeof(str), (LPARAM) str);
gg_checknewuser(gg, uin, str);
DBWriteContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, uin);
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemText(hwndDlg, IDC_EMAIL, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, str);
}
}
}
break;
}
}
return FALSE;
}
//----------------------------------------------------------------------
//
// main
//
// This routine is called when the OS starts up. It allocates a
// PCB for the first process - the one corresponding to the initial
// thread of execution. Note that the stack pointer is already
// set correctly by _osinit (assembly language code) to point
// to the stack for the 0th process. This stack isn't very big,
// though, so it should be replaced by the system stack of the
// currently running process.
//
//----------------------------------------------------------------------
void main (int argc, char *argv[])
{
int i,j;
int n;
char buf[120];
char *userprog = (char *)0;
int base=0;
int numargs=0;
char allargs[SIZE_ARG_BUFF];
int allargs_offset = 0;
debugstr[0] = '\0';
printf ("Got %d arguments.\n", argc);
printf ("Available memory: 0x%x -> 0x%x.\n", (int)lastosaddress, MemoryGetSize ());
printf ("Argument count is %d.\n", argc);
for (i = 0; i < argc; i++) {
printf ("Argument %d is %s.\n", i, argv[i]);
}
FsModuleInit ();
for (i = 0; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'D':
dstrcpy (debugstr, argv[++i]);
break;
case 'i':
n = dstrtol (argv[++i], (void *)0, 0);
ditoa (n, buf);
printf ("Converted %s to %d=%s\n", argv[i], n, buf);
break;
case 'f':
{
int start, codeS, codeL, dataS, dataL, fd, j;
int addr = 0;
static unsigned char buf[200];
fd = ProcessGetCodeInfo (argv[++i], &start, &codeS, &codeL, &dataS,
&dataL);
printf ("File %s -> start=0x%08x\n", argv[i], start);
printf ("File %s -> code @ 0x%08x (size=0x%08x)\n", argv[i], codeS,
codeL);
printf ("File %s -> data @ 0x%08x (size=0x%08x)\n", argv[i], dataS,
dataL);
while ((n = ProcessGetFromFile (fd, buf, &addr, sizeof (buf))) > 0)
{
for (j = 0; j < n; j += 4)
{
printf ("%08x: %02x%02x%02x%02x\n", addr + j - n, buf[j], buf[j+1],
buf[j+2], buf[j+3]);
}
}
close (fd);
break;
}
case 'u':
userprog = argv[++i];
base = i; // Save the location of the user program's name
break;
default:
printf ("Option %s not recognized.\n", argv[i]);
break;
}
if(userprog)
break;
}
}
dbprintf ('i', "About to initialize queues.\n");
AQueueModuleInit ();
dbprintf ('i', "After initializing queues.\n");
MemoryModuleInit ();
dbprintf ('i', "After initializing memory.\n");
ProcessModuleInit ();
dbprintf ('i', "After initializing processes.\n");
SynchModuleInit ();
dbprintf ('i', "After initializing synchronization tools.\n");
KbdModuleInit ();
dbprintf ('i', "After initializing keyboard.\n");
ClkModuleInit ();
dbprintf ('i', "After initializing clock.\n");
for (i = 0; i < 100; i++) {
buf[i] = 'a';
}
i = FsOpen ("vm", FS_MODE_WRITE);
dbprintf ('i', "VM Descriptor is %d\n", i);
FsSeek (i, 0, FS_SEEK_SET);
FsWrite (i, buf, 80);
FsClose (i);
// Setup command line arguments
if (userprog != (char *)0) {
numargs=0;
allargs_offset = 0;
// Move through each of the argv addresses
for(i=0; i<argc-base; i++) {
// At each argv address, copy the string into allargs, including the '\0'
for(j=0; allargs_offset < SIZE_ARG_BUFF; j++) {
allargs[allargs_offset++] = argv[i+base][j];
if (argv[i+base][j] == '\0') break; // end of this string
}
numargs++;
}
allargs[SIZE_ARG_BUFF-1] = '\0'; // set last char to NULL for safety
ProcessFork(0, (uint32)allargs, userprog, 1);
} else {
dbprintf('i', "No user program passed!\n");
}
ClkStart();
dbprintf ('i', "Set timer quantum to %d, about to run first process.\n",
processQuantum);
intrreturn ();
// Should never be called because the scheduler exits when there
// are no runnable processes left.
exitsim(); // NEVER RETURNS!
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: Account manager options dialog
INT_PTR CALLBACK gg_acc_mgr_guidlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
////////////////////////////////////////////////////////////////////////////////////////////
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = gg->getDword(GG_KEY_UIN, 0))
SetDlgItemTextA(hwndDlg, IDC_UIN, ditoa(num));
if (!gg->getString(GG_KEY_PASSWORD, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_PASSWORD, dbv.pszVal);
db_free(&dbv);
}
if (!gg->getString(GG_KEY_EMAIL, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_EMAIL, dbv.pszVal);
db_free(&dbv);
}
break;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_CREATEACCOUNT:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GetDlgItemTextA(hwndDlg, IDC_UIN, pass, _countof(pass));
dat.uin = atoi(pass);
GetDlgItemTextA(hwndDlg, IDC_PASSWORD, pass, _countof(pass));
GetDlgItemTextA(hwndDlg, IDC_EMAIL, email, _countof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
if (ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = gg->getDword(GG_KEY_UIN, 0))
SetDlgItemTextA(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemTextA(hwndDlg, IDC_UIN, "");
// Update password
if (!gg->getString(GG_KEY_PASSWORD, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_PASSWORD, dbv.pszVal);
db_free(&dbv);
}
else SetDlgItemTextA(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!gg->getString(GG_KEY_EMAIL, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_EMAIL, dbv.pszVal);
db_free(&dbv);
}
else SetDlgItemTextA(hwndDlg, IDC_EMAIL, "");
}
}
break;
case IDC_UIN:
case IDC_PASSWORD:
case IDC_EMAIL:
if (HIWORD(wParam) == EN_CHANGE && (HWND)lParam == GetFocus()) {
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->idFrom) {
case 0:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemTextA(hwndDlg, IDC_UIN, str, _countof(str));
uin = atoi(str);
GetDlgItemTextA(hwndDlg, IDC_PASSWORD, str, _countof(str));
gg->checknewuser(uin, str);
gg->setDword(GG_KEY_UIN, uin);
gg->setString(GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemTextA(hwndDlg, IDC_EMAIL, str, _countof(str));
gg->setString(GG_KEY_EMAIL, str);
}
}
}
break;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: Advanced options dialog
static INT_PTR CALLBACK gg_advoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
DBVARIANT dbv;
DWORD num;
switch (msg) {
case WM_INITDIALOG:
gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (!gg->getString(GG_KEY_SERVERHOSTS, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_HOST, dbv.pszVal);
db_free(&dbv);
}
else SetDlgItemTextA(hwndDlg, IDC_HOST, GG_KEYDEF_SERVERHOSTS);
CheckDlgButton(hwndDlg, IDC_KEEPALIVE, gg->getByte(GG_KEY_KEEPALIVE, GG_KEYDEF_KEEPALIVE) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_SHOWCERRORS, gg->getByte(GG_KEY_SHOWCERRORS, GG_KEYDEF_SHOWCERRORS) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_ARECONNECT, gg->getByte(GG_KEY_ARECONNECT, GG_KEYDEF_ARECONNECT) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_MSGACK, gg->getByte(GG_KEY_MSGACK, GG_KEYDEF_MSGACK) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_MANUALHOST, gg->getByte(GG_KEY_MANUALHOST, GG_KEYDEF_MANUALHOST) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_SSLCONN, gg->getByte(GG_KEY_SSLCONN, GG_KEYDEF_SSLCONN) ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(hwndDlg, IDC_HOST), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
EnableWindow(GetDlgItem(hwndDlg, IDC_PORT), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
CheckDlgButton(hwndDlg, IDC_DIRECTCONNS, gg->getByte(GG_KEY_DIRECTCONNS, GG_KEYDEF_DIRECTCONNS) ? BST_CHECKED : BST_UNCHECKED);
if (num = gg->getWord(GG_KEY_DIRECTPORT, GG_KEYDEF_DIRECTPORT))
SetDlgItemTextA(hwndDlg, IDC_DIRECTPORT, ditoa(num));
CheckDlgButton(hwndDlg, IDC_FORWARDING, gg->getByte(GG_KEY_FORWARDING, GG_KEYDEF_FORWARDING) ? BST_CHECKED : BST_UNCHECKED);
if (!gg->getString(GG_KEY_FORWARDHOST, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_FORWARDHOST, dbv.pszVal);
db_free(&dbv);
}
if (num = gg->getWord(GG_KEY_FORWARDPORT, GG_KEYDEF_FORWARDPORT))
SetDlgItemTextA(hwndDlg, IDC_FORWARDPORT, ditoa(num));
EnableWindow(GetDlgItem(hwndDlg, IDC_DIRECTPORT), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDING), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDPORT), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDHOST), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
break;
case WM_COMMAND:
if ((LOWORD(wParam) == IDC_DIRECTPORT || LOWORD(wParam) == IDC_FORWARDHOST || LOWORD(wParam) == IDC_FORWARDPORT)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_MANUALHOST:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_HOST), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
EnableWindow(GetDlgItem(hwndDlg, IDC_PORT), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
break;
}
case IDC_DIRECTCONNS:
case IDC_FORWARDING:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_DIRECTPORT), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDING), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDPORT), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDHOST), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
break;
}
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case WM_NOTIFY:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
char str[512];
gg->setByte(GG_KEY_KEEPALIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_KEEPALIVE));
gg->setByte(GG_KEY_SHOWCERRORS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWCERRORS));
gg->setByte(GG_KEY_ARECONNECT, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ARECONNECT));
gg->setByte(GG_KEY_MSGACK, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_MSGACK));
gg->setByte(GG_KEY_MANUALHOST, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
gg->setByte(GG_KEY_SSLCONN, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SSLCONN));
// Transfer settings
gg->setByte(GG_KEY_DIRECTCONNS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
gg->setByte(GG_KEY_FORWARDING, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FORWARDING));
// Write custom servers
GetDlgItemTextA(hwndDlg, IDC_HOST, str, _countof(str));
gg->setString(GG_KEY_SERVERHOSTS, str);
// Write direct port
GetDlgItemTextA(hwndDlg, IDC_DIRECTPORT, str, _countof(str));
gg->setWord(GG_KEY_DIRECTPORT, (WORD)atoi(str));
// Write forwarding host
GetDlgItemTextA(hwndDlg, IDC_FORWARDHOST, str, _countof(str));
gg->setString(GG_KEY_FORWARDHOST, str);
GetDlgItemTextA(hwndDlg, IDC_FORWARDPORT, str, _countof(str));
gg->setWord(GG_KEY_FORWARDPORT, (WORD)atoi(str));
break;
}
}
break;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: General options dialog
static INT_PTR CALLBACK gg_genoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = gg->getDword(GG_KEY_UIN, 0))
{
SetDlgItemTextA(hwndDlg, IDC_UIN, ditoa(num));
ShowWindow(GetDlgItem(hwndDlg, IDC_CREATEACCOUNT), SW_HIDE);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_REMOVEACCOUNT), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
}
if (!gg->getString(GG_KEY_PASSWORD, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_PASSWORD, dbv.pszVal);
db_free(&dbv);
}
if (!gg->getString(GG_KEY_EMAIL, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_EMAIL, dbv.pszVal);
db_free(&dbv);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
}
CheckDlgButton(hwndDlg, IDC_FRIENDSONLY, gg->getByte(GG_KEY_FRIENDSONLY, GG_KEYDEF_FRIENDSONLY) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_SHOWINVISIBLE, gg->getByte(GG_KEY_SHOWINVISIBLE, GG_KEYDEF_SHOWINVISIBLE) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_LEAVESTATUSMSG, gg->getByte(GG_KEY_LEAVESTATUSMSG, GG_KEYDEF_LEAVESTATUSMSG) ? BST_CHECKED : BST_UNCHECKED);
if (gg->gc_enabled)
CheckDlgButton(hwndDlg, IDC_IGNORECONF, gg->getByte(GG_KEY_IGNORECONF, GG_KEYDEF_IGNORECONF) ? BST_CHECKED : BST_UNCHECKED);
else
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IGNORECONF), FALSE);
CheckDlgButton(hwndDlg, IDC_IGNORECONF, BST_CHECKED);
}
CheckDlgButton(hwndDlg, IDC_IMGRECEIVE, gg->getByte(GG_KEY_IMGRECEIVE, GG_KEYDEF_IMGRECEIVE) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_SHOWLINKS, gg->getByte(GG_KEY_SHOWLINKS, GG_KEYDEF_SHOWLINKS) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_ENABLEAVATARS, gg->getByte(GG_KEY_ENABLEAVATARS, GG_KEYDEF_ENABLEAVATARS) ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)TranslateT("<Last Status>")); // 0
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(ID_STATUS_ONLINE, 0));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(ID_STATUS_AWAY, 0));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(ID_STATUS_DND, 0));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(ID_STATUS_FREECHAT, 0));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)pcli->pfnGetStatusModeDescription(ID_STATUS_INVISIBLE, 0));
switch(gg->getWord(GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS)) {
case ID_STATUS_ONLINE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 1, 0);
break;
case ID_STATUS_AWAY:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 2, 0);
break;
case ID_STATUS_DND:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 3, 0);
break;
case ID_STATUS_FREECHAT:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 4, 0);
break;
case ID_STATUS_INVISIBLE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 5, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 0, 0);
}
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)TranslateT("System tray icon"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)TranslateT("Popup window"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)TranslateT("Message with [img] BBCode"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_SETCURSEL, gg->getByte(GG_KEY_IMGMETHOD, GG_KEYDEF_IMGMETHOD), 0);
}
break;
case WM_COMMAND:
if ((LOWORD(wParam) == IDC_UIN || LOWORD(wParam) == IDC_PASSWORD || LOWORD(wParam) == IDC_EMAIL)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_EMAIL:
case IDC_UIN:
gg_optsdlgcheck(hwndDlg);
break;
case IDC_LEAVESTATUSMSG:
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
break;
case IDC_IMGRECEIVE:
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
break;
case IDC_LOSTPASS:
{
char email[128];
uin_t uin;
GetDlgItemTextA(hwndDlg, IDC_UIN, email, _countof(email));
uin = atoi(email);
GetDlgItemTextA(hwndDlg, IDC_EMAIL, email, _countof(email));
if (!mir_strlen(email))
MessageBox(NULL, TranslateT("You need to specify your registration e-mail first."),
gg->m_tszUserName, MB_OK | MB_ICONEXCLAMATION);
else if (MessageBox(NULL,
TranslateT("Your password will be sent to your registration e-mail.\nDo you want to continue?"),
gg->m_tszUserName,
MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
gg->remindpassword(uin, email);
return FALSE;
}
case IDC_CREATEACCOUNT:
case IDC_REMOVEACCOUNT:
if (gg->isonline())
{
if (MessageBox(
NULL,
TranslateT("You should disconnect before making any permanent changes with your account.\nDo you want to disconnect now?"),
gg->m_tszUserName,
MB_OKCANCEL | MB_ICONEXCLAMATION) == IDCANCEL)
break;
else
gg->disconnect();
}
case IDC_CHPASS:
case IDC_CHEMAIL:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GetDlgItemTextA(hwndDlg, IDC_UIN, pass, _countof(pass));
dat.uin = atoi(pass);
GetDlgItemTextA(hwndDlg, IDC_PASSWORD, pass, _countof(pass));
GetDlgItemTextA(hwndDlg, IDC_EMAIL, email, _countof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
if (LOWORD(wParam) == IDC_CREATEACCOUNT)
{
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if (LOWORD(wParam) == IDC_CHPASS)
{
dat.mode = GG_USERUTIL_PASS;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHPASS), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if (LOWORD(wParam) == IDC_CHEMAIL)
{
dat.mode = GG_USERUTIL_EMAIL;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHEMAIL), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else
{
dat.mode = GG_USERUTIL_REMOVE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_REMOVEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
if (ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = gg->getDword(GG_KEY_UIN, 0))
SetDlgItemTextA(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemTextA(hwndDlg, IDC_UIN, "");
// Update password
if (!gg->getString(GG_KEY_PASSWORD, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_PASSWORD, dbv.pszVal);
db_free(&dbv);
}
else SetDlgItemTextA(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!gg->getString(GG_KEY_EMAIL, &dbv)) {
SetDlgItemTextA(hwndDlg, IDC_EMAIL, dbv.pszVal);
db_free(&dbv);
}
else SetDlgItemTextA(hwndDlg, IDC_EMAIL, "");
// Update links
gg_optsdlgcheck(hwndDlg);
// Remove details
if (LOWORD(wParam) != IDC_CHPASS && LOWORD(wParam) != IDC_CHEMAIL)
{
gg->delSetting(GG_KEY_NICK);
gg->delSetting(GG_KEY_PD_NICKNAME);
gg->delSetting(GG_KEY_PD_CITY);
gg->delSetting(GG_KEY_PD_FIRSTNAME);
gg->delSetting(GG_KEY_PD_LASTNAME);
gg->delSetting(GG_KEY_PD_FAMILYNAME);
gg->delSetting(GG_KEY_PD_FAMILYCITY );
gg->delSetting(GG_KEY_PD_AGE);
gg->delSetting(GG_KEY_PD_BIRTHYEAR);
gg->delSetting(GG_KEY_PD_GANDER);
}
}
}
break;
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case WM_NOTIFY:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
int status_flags = GG_STATUS_FLAG_UNKNOWN;
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemTextA(hwndDlg, IDC_UIN, str, _countof(str));
uin = atoi(str);
GetDlgItemTextA(hwndDlg, IDC_PASSWORD, str, _countof(str));
gg->checknewuser(uin, str);
gg->setDword(GG_KEY_UIN, uin);
gg->setString(GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemTextA(hwndDlg, IDC_EMAIL, str, _countof(str));
gg->setString(GG_KEY_EMAIL, str);
// Write checkboxes
gg->setByte(GG_KEY_FRIENDSONLY, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FRIENDSONLY));
gg->setByte(GG_KEY_SHOWINVISIBLE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWINVISIBLE));
gg->setByte(GG_KEY_LEAVESTATUSMSG, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
if (gg->gc_enabled)
gg->setByte(GG_KEY_IGNORECONF, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IGNORECONF));
gg->setByte(GG_KEY_IMGRECEIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
gg->setByte(GG_KEY_SHOWLINKS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS));
if (IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS))
status_flags |= GG_STATUS_FLAG_SPAM;
gg->gg_EnterCriticalSection(&gg->sess_mutex, "gg_genoptsdlgproc", 34, "sess_mutex", 1);
gg_change_status_flags(gg->sess, status_flags);
gg->gg_LeaveCriticalSection(&gg->sess_mutex, "gg_genoptsdlgproc", 34, 1, "sess_mutex", 1);
gg->setByte(GG_KEY_ENABLEAVATARS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ENABLEAVATARS));
gg->setByte(GG_KEY_IMGMETHOD, (BYTE)SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_GETCURSEL, 0, 0));
// Write leave status
switch(SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_GETCURSEL, 0, 0)) {
case 1:
gg->setWord(GG_KEY_LEAVESTATUS, ID_STATUS_ONLINE);
break;
case 2:
gg->setWord(GG_KEY_LEAVESTATUS, ID_STATUS_AWAY);
break;
case 3:
gg->setWord(GG_KEY_LEAVESTATUS, ID_STATUS_DND);
break;
case 4:
gg->setWord(GG_KEY_LEAVESTATUS, ID_STATUS_FREECHAT);
break;
case 5:
gg->setWord(GG_KEY_LEAVESTATUS, ID_STATUS_INVISIBLE);
break;
default:
gg->setWord(GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS);
}
}
break;
}
return FALSE;
}
void main (int argc, char *argv[])
{
int numprocs = 0; // Used to store number of processes to create
int i; // Loop index variable
missile_code *mc; // Used to get address of shared memory page
uint32 h_mem; // Used to hold handle to shared memory page
sem_t s_procs_completed; // Semaphore used to wait until all spawned processes have completed
char h_mem_str[10]; // Used as command-line argument to pass mem_handle to new processes
char s_procs_completed_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
if (argc != 2) {
Printf("Usage: "); Printf(argv[0]); Printf(" <number of processes to create>\n");
Exit();
}
// Convert string from ascii command line argument to integer number
numprocs = dstrtol(argv[1], NULL, 10); // the "10" means base 10
Printf("Creating %d processes\n", numprocs);
// Allocate space for a shared memory page, which is exactly 64KB
// Note that it doesn't matter how much memory we actually need: we
// always get 64KB
if ((h_mem = shmget()) == 0) {
Printf("ERROR: could not allocate shared memory page in "); Printf(argv[0]); Printf(", exiting...\n");
Exit();
}
// Map shared memory page into this process's memory space
if ((mc = (missile_code *)shmat(h_mem)) == NULL) {
Printf("Could not map the shared page to virtual address in "); Printf(argv[0]); Printf(", exiting..\n");
Exit();
}
// Put some values in the shared memory, to be read by other processes
mc->numprocs = numprocs;
mc->really_important_char = 'A';
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete. To do this, we will initialize
// the semaphore to (-1) * (number of signals), where "number of signals"
// should be equal to the number of processes we're spawning - 1. Once
// each of the processes has signaled, the semaphore should be back to
// zero and the final sem_wait below will return.
if ((s_procs_completed = sem_create(-(numprocs-1))) == SYNC_FAIL) {
Printf("Bad sem_create in "); Printf(argv[0]); Printf("\n");
Exit();
}
// Setup the command-line arguments for the new process. We're going to
// pass the handles to the shared memory page and the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(h_mem, h_mem_str);
ditoa(s_procs_completed, s_procs_completed_str);
// Now we can create the processes. Note that you MUST end your call to
// process_create with a NULL argument so that the operating system
// knows how many arguments you are sending.
for(i=0; i<numprocs; i++) {
Printf("h_mem_str : %s semaphore_str : %s", h_mem_str, s_procs_completed_str);
process_create(FILENAME_TO_RUN, h_mem_str, s_procs_completed_str, NULL);
Printf("Process %d created\n", i);
}
// And finally, wait until all spawned processes have finished.
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in ", s_procs_completed); Printf(argv[0]); Printf("\n");
Exit();
}
Printf("All other processes completed, exiting main process.\n");
}
HWND GGPROTO::SearchAdvanced(HWND hwndDlg)
{
gg_pubdir50_t req;
TCHAR text[64];
char data[800] = "\0";
unsigned long crc;
// Check if connected
if (!isonline()) return (HWND)0;
if (!(req = gg_pubdir50_new(GG_PUBDIR50_SEARCH)))
{
#ifdef DEBUGMODE
debugLogA("SearchAdvanced(): ForkThread 14 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HWND)1;
}
// Fetch search data
GetDlgItemText(hwndDlg, IDC_FIRSTNAME, text, sizeof(text));
if (_tcslen(text))
{
char *firstName_utf8 = mir_utf8encodeT(text);
gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, firstName_utf8);
strncat(data, firstName_utf8, sizeof(data) - strlen(data));
mir_free(firstName_utf8);
}
/* 1 */ strncat(data, ".", sizeof(data) - strlen(data));
GetDlgItemText(hwndDlg, IDC_LASTNAME, text, sizeof(text));
if (_tcslen(text))
{
char *lastName_utf8 = mir_utf8encodeT(text);
gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, lastName_utf8);
strncat(data, lastName_utf8, sizeof(data) - strlen(data));
mir_free(lastName_utf8);
}
/* 2 */ strncat(data, ".", sizeof(data) - strlen(data));
GetDlgItemText(hwndDlg, IDC_NICKNAME, text, sizeof(text));
if (_tcslen(text))
{
char *nickName_utf8 = mir_utf8encodeT(text);
gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, nickName_utf8);
strncat(data, nickName_utf8, sizeof(data) - strlen(data));
mir_free(nickName_utf8);
}
/* 3 */ strncat(data, ".", sizeof(data) - strlen(data));
GetDlgItemText(hwndDlg, IDC_CITY, text, sizeof(text));
if (_tcslen(text))
{
char *city_utf8 = mir_utf8encodeT(text);
gg_pubdir50_add(req, GG_PUBDIR50_CITY, city_utf8);
strncat(data, city_utf8, sizeof(data) - strlen(data));
mir_free(city_utf8);
}
/* 4 */ strncat(data, ".", sizeof(data) - strlen(data));
GetDlgItemText(hwndDlg, IDC_AGEFROM, text, sizeof(text));
if (_tcslen(text))
{
int yearTo = _tstoi(text);
int yearFrom;
time_t t = time(NULL);
struct tm *lt = localtime(&t);
int ay = lt->tm_year + 1900;
char age[16];
GetDlgItemTextA(hwndDlg, IDC_AGETO, age, sizeof(age));
yearFrom = atoi(age);
// Count & fix ranges
if (!yearTo)
yearTo = ay;
else
yearTo = ay - yearTo;
if (!yearFrom)
yearFrom = 0;
else
yearFrom = ay - yearFrom;
mir_sntprintf(text, sizeof(text), _T("%d %d"), yearFrom, yearTo);
char *age_utf8 = mir_utf8encodeT(text);
gg_pubdir50_add(req, GG_PUBDIR50_BIRTHYEAR, age_utf8);
strncat(data, age_utf8, sizeof(data) - strlen(data));
mir_free(age_utf8);
}
/* 5 */ strncat(data, ".", sizeof(data) - strlen(data));
switch(SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_GETCURSEL, 0, 0))
{
case 1:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_FEMALE);
strncat(data, GG_PUBDIR50_GENDER_MALE, sizeof(data) - strlen(data));
break;
case 2:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_MALE);
strncat(data, GG_PUBDIR50_GENDER_FEMALE, sizeof(data) - strlen(data));
break;
}
/* 6 */ strncat(data, ".", sizeof(data) - strlen(data));
if (IsDlgButtonChecked(hwndDlg, IDC_ONLYCONNECTED))
{
gg_pubdir50_add(req, GG_PUBDIR50_ACTIVE, GG_PUBDIR50_ACTIVE_TRUE);
strncat(data, GG_PUBDIR50_ACTIVE_TRUE, sizeof(data) - strlen(data));
}
/* 7 */ strncat(data, ".", sizeof(data) - strlen(data));
// No data entered
if (strlen(data) <= 7 || (strlen(data) == 8 && IsDlgButtonChecked(hwndDlg, IDC_ONLYCONNECTED))) return (HWND)0;
// Count crc & check if the data was equal if yes do same search with shift
crc = crc_get(data);
if (crc == last_crc && next_uin)
gg_pubdir50_add(req, GG_PUBDIR50_START, ditoa(next_uin));
else
last_crc = crc;
gg_pubdir50_seq_set(req, GG_SEQ_SEARCH);
if (isonline())
{
gg_EnterCriticalSection(&sess_mutex, "SearchAdvanced", 52, "sess_mutex", 1);
if (!gg_pubdir50(sess, req))
{
gg_LeaveCriticalSection(&sess_mutex, "SearchAdvanced", 52, 1, "sess_mutex", 1);
#ifdef DEBUGMODE
debugLogA("SearchAdvanced(): ForkThread 15 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HWND)1;
}
gg_LeaveCriticalSection(&sess_mutex, "SearchAdvanced", 52, 2, "sess_mutex", 1);
}
debugLogA("SearchAdvanced(): Seq %d.", req->seq);
gg_pubdir50_free(req);
return (HWND)1;
}
void main (int argc, char *argv[])
{
int num_hello_world = 0; // Used to store number of processes to create
int i; // Loop index variable
sem_t s_procs_completed; // Semaphore used to wait until all spawned processes have completed
sem_t test_5;
char s_procs_completed_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
char test_5_str[10];
if (argc != 2) {
Printf("Usage: %s <number of hello world processes to create>\n", argv[0]);
Exit();
}
// Convert string from ascii command line argument to integer number
num_hello_world = dstrtol(argv[1], NULL, 10); // the "10" means base 10
Printf("makeprocs (%d): Creating %d test cases\n", getpid(), num_hello_world);
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete.
if ((s_procs_completed = sem_create(0)) == SYNC_FAIL) {
Printf("makeprocs (%d): Bad sem_create\n", getpid());
Exit();
}
if ((test_5 = sem_create(-29)) == SYNC_FAIL) {
Printf("makeprocs (%d): Bad sem_create\n", getpid());
Exit();
}
// Setup the command-line arguments for the new processes. We're going to
// pass the handles to the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(s_procs_completed, s_procs_completed_str);
ditoa(test_5,test_5_str);
// Create Hello World processes
// Printf("-------------------------------------------------------------------------------------\n");
// Printf("makeprocs (%d): Creating %d hello world's in a row, but only one runs at a time\n", getpid(), num_hello_world);
// for(i=0; i<num_hello_world; i++) {
Printf("makeprocs (%d): Creating Test case #0\n", getpid());
process_create(HELLO_WORLD_0, s_procs_completed_str, NULL);
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
Printf("makeprocs (%d): Creating Test case #1\n", getpid());
process_create(HELLO_WORLD_1, s_procs_completed_str, NULL);
// sem_signal(s_procs_completed);
// if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
// Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
// Exit();
// }
for(i=0;i<10000;i++);//loop for time to display error info
Printf("Test case (1): Done!\n");
Printf("------------------------------------------------------------------------------------\n");
Printf("makeprocs (%d): Creating Test case #2\n", getpid());
process_create(HELLO_WORLD_2, s_procs_completed_str, NULL);
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
Printf("makeprocs (%d): Creating Test case #3\n", getpid());
process_create(HELLO_WORLD_3, s_procs_completed_str, NULL);
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
Printf("makeprocs (%d): Creating Test case #4\n", getpid());
for(i=0;i<100;i++){
process_create(HELLO_WORLD_4, s_procs_completed_str, NULL);
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
Printf("running hello_world program %d times\n",i+1);
}
Printf("Test case (4): Done!\n");
Printf("------------------------------------------------------------------------------------\n");
Printf("makeprocs (%d): Creating Test case #5\n", getpid());
for(i=0;i<30;i++){
process_create(HELLO_WORLD_5, test_5_str, NULL);
}
if (sem_wait(test_5) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in %s\n", s_procs_completed, argv[0]);
Exit();
}
Printf("Test case (5):Done!\n");
Printf("-------------------------------------------------------------------------------------\n");
// }
Printf("-------------------------------------------------------------------------------------\n");
Printf("makeprocs (%d): All other processes completed, exiting main process.\n", getpid());
}
void update_temp2(int t) {
master_temp2 = t;
ditoa(temp2_str, sizeof(temp2_str), t);
text_layer_set_text(temp2_layer, temp2_str);
alarm_check();
}
HANDLE GGPROTO::SearchByName(const TCHAR *nick, const TCHAR *firstName, const TCHAR *lastName)
{
// Check if connected and if there's a search data
if (!isonline())
return 0;
if (!nick && !firstName && !lastName)
return 0;
gg_pubdir50_t req = gg_pubdir50_new(GG_PUBDIR50_SEARCH);
if (req == NULL) {
#ifdef DEBUGMODE
debugLogA("SearchByName(): ForkThread 12 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HANDLE)1;
}
// Add nick,firstName,lastName and search it
CMStringA szQuery;
if (nick)
{
T2Utf nick_utf8(nick);
gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, nick_utf8);
szQuery.Append(nick_utf8);
}
szQuery.AppendChar('.');
if (firstName)
{
T2Utf firstName_utf8(firstName);
gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, firstName_utf8);
szQuery.Append(firstName_utf8);
}
szQuery.AppendChar('.');
if (lastName)
{
T2Utf lastName_utf8(lastName);
gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, lastName_utf8);
szQuery.Append(lastName_utf8);
}
szQuery.AppendChar('.');
// Count crc & check if the data was equal if yes do same search with shift
unsigned long crc = crc_get(szQuery.GetBuffer());
if (crc == last_crc && next_uin)
gg_pubdir50_add(req, GG_PUBDIR50_START, ditoa(next_uin));
else
last_crc = crc;
gg_pubdir50_seq_set(req, GG_SEQ_SEARCH);
gg_EnterCriticalSection(&sess_mutex, "SearchByName", 51, "sess_mutex", 1);
if (!gg_pubdir50(sess, req))
{
gg_LeaveCriticalSection(&sess_mutex, "SearchByName", 51, 1, "sess_mutex", 1);
#ifdef DEBUGMODE
debugLogA("SearchByName(): ForkThread 13 GGPROTO::searchthread");
#endif
ForkThread(&GGPROTO::searchthread, NULL);
return (HANDLE)1;
}
gg_LeaveCriticalSection(&sess_mutex, "SearchByName", 51, 2, "sess_mutex", 1);
debugLogA("SearchByName(): Seq %d.", req->seq);
gg_pubdir50_free(req);
return (HANDLE)1;
}
void main (int argc, char *argv[])
{
int numprocs = 5; // Used to store number of processes to create
int i; // Loop index variable
phil *p; // Used to get address of shared memory page
uint32 h_mem; // Used to hold handle to shared memory page
sem_t s_procs_completed; // Semaphore used to wait until all spawned processes have completed
char h_mem_str[10]; // Used as command-line argument to pass mem_handle to new processes
char s_procs_completed_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
char i_str[2];
if (argc != 1) {
Printf("Usage: ");
Printf(argv[0]);
Printf("\n");
Exit();
}
Printf("Creating %d processes\n", numprocs);
// Allocate space for a shared memory page, which is exactly 64KB
// Note that it doesn't matter how much memory we actually need: we
// always get 64KB
if ((h_mem = shmget()) == 0) {
Printf("ERROR: could not allocate shared memory page in "); Printf(argv[0]); Printf(", exiting...\n");
Exit();
}
// Map shared memory page into this process's memory space
if ((p = (phil *)shmat(h_mem)) == NULL) {
Printf("Could not map the shared page to virtual address in "); Printf(argv[0]); Printf(", exiting..\n");
Exit();
}
// Put some values in the shared memory, to be read by other processes
for (i = 0; i < 5; i++){
p->state[i] = THINKING;
p->wait_locks[i] = lock_create();
p->self[i] = cond_create(p->wait_locks[i]);
p->eaten[i] = 0;
}
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete. To do this, we will initialize
// the semaphore to (-1) * (number of signals), where "number of signals"
// should be equal to the number of processes we're spawning - 1. Once
// each of the processes has signaled, the semaphore should be back to
// zero and the final sem_wait below will return.
if ((s_procs_completed = sem_create(-(numprocs-1))) == SYNC_FAIL) {
Printf("Bad sem_create in "); Printf(argv[0]); Printf("\n");
Exit();
}
// Setup the command-line arguments for the new process. We're going to
// pass the handles to the shared memory page and the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(h_mem, h_mem_str);
ditoa(s_procs_completed, s_procs_completed_str);
// Now we can create the processes. Note that you MUST end your call to
// process_create with a NULL argument so that the operating system
// knows how many arguments you are sending.
for(i=0; i<numprocs; i++) {
ditoa(i, i_str);
process_create(FILENAME_TO_RUN, h_mem_str, s_procs_completed_str, i_str , NULL);
Printf("Process %d created\n", i);
}
// And finally, wait until all spawned processes have finished.
if (sem_wait(s_procs_completed) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in ", s_procs_completed); Printf(argv[0]); Printf("\n");
Exit();
}
for (i = 0; i < numprocs; i++){
if (p->eaten[i] == 1){
Printf("Philosopher %d has eaten\n", i);
}else{
Printf("Philosopher %d DID NOT eat\n", i);
}
}
Printf("All other processes completed, exiting main process.\n");
}
void main (int argc, char *argv[])
{
int numprocs = 0; // Used to store number of processes to create
int i; // Loop index variable
circular_buffer *cb; // Used to get address of shared memory page
uint32 h_mem; // Used to hold handle to shared memory page
sem_t h_procs_sem; // Semaphore used to wait until all spawned processes have completed
lock_t h_cb_lock; // LOCK handles
cond_t h_nFull_cv, h_nEmpty_cv; // Condition variables
char h_mem_str[10]; // Used as command-line argument to pass mem_handle to new processes
char h_procs_sem_str[10]; // Used as command-line argument to pass page_mapped handle to new processes
char h_cb_lock_str[10];
char h_nFull_cv_str[10]; // Used as command-line arg
char h_nEmpty_cv_str[10]; // Used as command-line arg
if (argc != 2) {
Printf("Usage: "); Printf(argv[0]); Printf(" <number of processes to create>\n");
Exit();
}
// Convert string from ascii command line argument to integer number
numprocs = dstrtol(argv[1], NULL, 10); // the "10" means base 10
Printf("Creating %d processes\n", 2*numprocs);
// Allocate space for a shared memory page, which is exactly 64KB
// Note that it doesn't matter how much memory we actually need: we
// always get 64KB
if ((h_mem = shmget()) == 0) {
Printf("ERROR: could not allocate shared memory page in "); Printf(argv[0]); Printf(", exiting...\n");
Exit();
}
// Map shared memory page into this process's memory space
if ((cb = (circular_buffer *)shmat(h_mem)) == NULL) {
Printf("Could not map the shared page to virtual address in "); Printf(argv[0]); Printf(", exiting..\n");
Exit();
}
// Put some values in the shared memory, to be read by other processes
cb->head = 0;
cb->tail = 0;
// Create semaphore to not exit this process until all other processes
// have signalled that they are complete. To do this, we will initialize
// the semaphore to (-1) * (number of signals), where "number of signals"
// should be equal to the number of processes we're spawning - 1. Once
// each of the processes has signaled, the semaphore should be back to
// zero and the final sem_wait below will return.
if ((h_procs_sem = sem_create(-(numprocs*2-1))) == SYNC_FAIL) {
Printf("Bad sem_create in "); Printf(argv[0]); Printf("\n");
Exit();
}
if((h_cb_lock = lock_create()) == SYNC_FAIL) {
Printf("Bad lock_create in ");
Exit();
}
if((h_nFull_cv = cond_create(h_cb_lock)) == SYNC_FAIL) {
Printf("Bad cond_create in ");
Exit();
}
if((h_nEmpty_cv = cond_create(h_cb_lock)) == SYNC_FAIL) {
Printf("Bad cond_create in ");
Exit();
}
// Setup the command-line arguments for the new process. We're going to
// pass the handles to the shared memory page and the semaphore as strings
// on the command line, so we must first convert them from ints to strings.
ditoa(h_mem, h_mem_str);
ditoa(h_procs_sem, h_procs_sem_str);
ditoa(h_cb_lock, h_cb_lock_str);
ditoa(h_nFull_cv, h_nFull_cv_str);
ditoa(h_nEmpty_cv, h_nEmpty_cv_str);
// Now we can create the processes. Note that you MUST end your call to
// process_create with a NULL argument so that the operating system
// knows how many arguments you are sending.
for(i=0; i < numprocs; i++) {
process_create(CONSUMER_TO_RUN, h_mem_str, h_procs_sem_str, h_cb_lock_str, h_nFull_cv_str, h_nEmpty_cv_str, NULL);
process_create(PRODUCER_TO_RUN, h_mem_str, h_procs_sem_str, h_cb_lock_str, h_nFull_cv_str, h_nEmpty_cv_str, NULL);
Printf("Process %d created\n", i);
}
// And finally, wait until all spawned processes have finished.
if (sem_wait(h_procs_sem) != SYNC_SUCCESS) {
Printf("Bad semaphore s_procs_completed (%d) in ", h_procs_sem); Printf(argv[0]); Printf("\n");
Exit();
}
Printf("All other processes completed, exiting main process.\n");
}
main (int argc, char *argv[])
{
int number, i, j, offset;
uint32 handle;
sem_t spage; sem_t ipc_sem;
char num_str[10], spage_str[10], handle_str[10], ipc_str[10];
DB * db;
switch(argc)
{
case 2:
handle = shmget();
db = (DB *)shmat(handle);
if(db == NULL)
{
Printf("Could not map the shared page to virtual address, exiting..\n");
exit();
}
db->end = 0; // Initially the end flag is 0
spage = sem_create(0);
ipc_sem = cond_create(0);
ditoa(handle, handle_str);
ditoa(spage, spage_str);
number = dstrtol(argv[1], NULL, 10);
Printf("Setting number = %d\n", number);
for(i = 0; i < number; i++)
{
//Printf("Current process : %d\n", i);
ditoa(i, num_str);
process_create("userprog4.dlx.obj", 1 + i, 0, num_str,
spage_str, handle_str,
NULL); // different p_nice for child process
}
sem_wait(spage); // wait for the children to reach 200
db->end = 1; // terminate children processes
break;
case 4:
offset = dstrtol(argv[1], NULL, 10);
spage = dstrtol(argv[2], NULL, 10);
//ipc_sem = dstrtol(argv[3], NULL, 10);
handle = dstrtol(argv[3], NULL, 10);
db = (DB *)shmat(handle);
if(db == NULL)
{
Printf("Could not map the virtual address to the memory, exiting...\n");
exit();
}
sleep(100);
for(i = 0; !db->end; i ++)
{
for(j = 0; j < 50000; j++)
{
//#ifdef sleep
if(offset == 1 && j % 1000 == 0 && j <= 30000)
sleep(1);
//# endif
#ifdef dynamic
if(offset == 0 && j % 500 == 0 && j <= 3000)
cond_wait(ipc_sem);
if(offset == 1 && j % 600 == 0)
cond_signal(ipc_sem);
# endif
} //waste some time
Printf("%c%d\n",'A'+offset, i);
if(i > 200) sem_signal(spage); //signal end
}
Printf("***** Process %d reached %d *****\n", getpid(), i);
/*
The expected output for the following run
dlxsim -x os.dlx.obj -a -u userprog4.dlx.obj 2
is that the first process reaches an "i" which is roughly half
of the "i" reached by the second process. This implies the
second process gets scheduled for twice the time of the first
process.
Our output is
***** Process 29 reached 203 *****
***** Process 30 reached 101 *****
Your output may differ a little bit due to randomness.
*/
break;
default:
Printf("Usage: ");
Printf(argv[0]);
Printf(" number\n");
Printf("argc = %d\n", argc);
exit();
}
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: General options dialog
static INT_PTR CALLBACK gg_genoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
{
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
ShowWindow(GetDlgItem(hwndDlg, IDC_CREATEACCOUNT), SW_HIDE);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_REMOVEACCOUNT), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
}
CheckDlgButton(hwndDlg, IDC_FRIENDSONLY, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, GG_KEYDEF_FRIENDSONLY));
CheckDlgButton(hwndDlg, IDC_SHOWINVISIBLE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, GG_KEYDEF_SHOWINVISIBLE));
CheckDlgButton(hwndDlg, IDC_LEAVESTATUSMSG, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, GG_KEYDEF_LEAVESTATUSMSG));
if(gg->gc_enabled)
CheckDlgButton(hwndDlg, IDC_IGNORECONF, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, GG_KEYDEF_IGNORECONF));
else
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IGNORECONF), FALSE);
CheckDlgButton(hwndDlg, IDC_IGNORECONF, TRUE);
}
CheckDlgButton(hwndDlg, IDC_IMGRECEIVE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, GG_KEYDEF_IMGRECEIVE));
CheckDlgButton(hwndDlg, IDC_SHOWLINKS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, GG_KEYDEF_SHOWLINKS));
CheckDlgButton(hwndDlg, IDC_ENABLEAVATARS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, GG_KEYDEF_ENABLEAVATARS));
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("<Last Status>")); // 0
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Online")); // ID_STATUS_ONLINE
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Away")); // ID_STATUS_AWAY
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("DND")); // ID_STATUS_DND
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Free for chat")); // ID_STATUS_FREECHAT
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Invisible")); // ID_STATUS_INVISIBLE
switch(DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS))
{
case ID_STATUS_ONLINE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 1, 0);
break;
case ID_STATUS_AWAY:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 2, 0);
break;
case ID_STATUS_DND:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 3, 0);
break;
case ID_STATUS_FREECHAT:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 4, 0);
break;
case ID_STATUS_INVISIBLE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 5, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 0, 0);
}
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("System tray icon"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Popup window"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Message with [img] BBCode"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_SETCURSEL,
DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD, GG_KEYDEF_IMGMETHOD), 0);
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) == IDC_UIN || LOWORD(wParam) == IDC_PASSWORD || LOWORD(wParam) == IDC_EMAIL)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_EMAIL:
case IDC_UIN:
{
gg_optsdlgcheck(hwndDlg);
break;
}
case IDC_LEAVESTATUSMSG:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
break;
}
case IDC_IMGRECEIVE:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
break;
}
case IDC_LOSTPASS:
{
char email[128];
uin_t uin;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, email, sizeof(email));
uin = atoi(email);
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
if(!strlen(email))
MessageBox(
NULL,
Translate("You need to specify your registration e-mail first."),
GG_PROTONAME,
MB_OK | MB_ICONEXCLAMATION);
else if(MessageBox(
NULL,
Translate("Your password will be sent to your registration e-mail.\nDo you want to continue ?"),
GG_PROTONAME,
MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
gg_remindpassword(gg, uin, email);
return FALSE;
}
case IDC_CREATEACCOUNT:
case IDC_REMOVEACCOUNT:
if(gg_isonline((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA)))
{
if(MessageBox(
NULL,
Translate("You should disconnect before making any permanent changes with your account.\nDo you want to disconnect now ?"),
((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA))->proto.m_szModuleName,
MB_OKCANCEL | MB_ICONEXCLAMATION) == IDCANCEL)
break;
else
gg_disconnect((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA));
}
case IDC_CHPASS:
case IDC_CHEMAIL:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, pass, sizeof(pass));
dat.uin = atoi(pass);
GetDlgItemText(hwndDlg, IDC_PASSWORD, pass, sizeof(pass));
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
if(LOWORD(wParam) == IDC_CREATEACCOUNT)
{
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHPASS)
{
dat.mode = GG_USERUTIL_PASS;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHPASS), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHEMAIL)
{
dat.mode = GG_USERUTIL_EMAIL;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHEMAIL), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else
{
dat.mode = GG_USERUTIL_REMOVE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_REMOVEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
if(ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemText(hwndDlg, IDC_UIN, "");
// Update password
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_EMAIL, "");
// Update links
gg_optsdlgcheck(hwndDlg);
// Remove details
if(LOWORD(wParam) != IDC_CHPASS && LOWORD(wParam) != IDC_CHEMAIL)
{
DBDeleteContactSetting(NULL, GG_PROTO, GG_KEY_NICK);
DBDeleteContactSetting(NULL, GG_PROTO, "NickName");
DBDeleteContactSetting(NULL, GG_PROTO, "City");
DBDeleteContactSetting(NULL, GG_PROTO, "FirstName");
DBDeleteContactSetting(NULL, GG_PROTO, "LastName");
DBDeleteContactSetting(NULL, GG_PROTO, "FamilyName");
DBDeleteContactSetting(NULL, GG_PROTO, "CityOrigin");
DBDeleteContactSetting(NULL, GG_PROTO, "Age");
DBDeleteContactSetting(NULL, GG_PROTO, "BirthYear");
DBDeleteContactSetting(NULL, GG_PROTO, "Gender");
}
}
}
break;
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
int status_flags = GG_STATUS_FLAG_UNKNOWN;
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemText(hwndDlg, IDC_UIN, str, sizeof(str));
uin = atoi(str);
GetDlgItemText(hwndDlg, IDC_PASSWORD, str, sizeof(str));
CallService(MS_DB_CRYPT_ENCODESTRING, sizeof(str), (LPARAM) str);
gg_checknewuser(gg, uin, str);
DBWriteContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, uin);
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemText(hwndDlg, IDC_EMAIL, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, str);
// Write checkboxes
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FRIENDSONLY));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWINVISIBLE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
if (gg->gc_enabled)
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IGNORECONF));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS));
if (IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS))
status_flags |= GG_STATUS_FLAG_SPAM;
EnterCriticalSection(&gg->sess_mutex);
gg_change_status_flags(gg->sess, status_flags);
LeaveCriticalSection(&gg->sess_mutex);
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ENABLEAVATARS));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD,
(BYTE)SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_GETCURSEL, 0, 0));
// Write leave status
switch(SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_GETCURSEL, 0, 0))
{
case 1:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_ONLINE);
break;
case 2:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_AWAY);
break;
case 3:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_DND);
break;
case 4:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_FREECHAT);
break;
case 5:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_INVISIBLE);
break;
default:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS);
}
break;
}
}
break;
}
}
return FALSE;
}