/*********************************************************************** * * FUNCTION: SubstituteStr * * DESCRIPTION: This routine substitutes the occurrence a token, within * a string, with another string. * * PARAMETERS: str - string containing token string * token - the string to be replaced * sub - the string to substitute for the token * subLen - length of the substitute string. * * RETURNED: pointer to the string * ***********************************************************************/ static Char* SubstituteStr(Char* str, const Char* token, const Char* sub, UInt16 subLen) { const UInt16 tokenLen = StrLen(token); const UInt16 charsToMove = subLen - tokenLen; const UInt16 strLen = StrLen(str); MemHandle strH = MemPtrRecoverHandle(str); const UInt16 blockSize = MemHandleSize(strH); Char* ptr = StrStr(str, token); ASSERT(str); ASSERT(token); ASSERT(sub); /* Find the start of the token string, if it doesn't exist, exit. */ if (ptr == NULL) return str; /* Resize the string if necessary. */ if (strLen + charsToMove + 1 >= blockSize) { MemHandleUnlock(strH); MemHandleResize(strH, strLen + charsToMove + 1); str = MemHandleLock(strH); ASSERT(str); ptr = StrStr(str, token); ASSERT(ptr); } /* Make room for the substitute string. */ if (charsToMove) MemMove(ptr + subLen, ptr + tokenLen, StrLen (ptr + tokenLen)+1); /* Replace the token with the substitute string. */ MemMove(ptr, sub, subLen); return str; }
void OSystem_PalmZodiac::undraw_mouse() { if (!_mouseDrawn) return; int h = _mouseOldState.h; // no need to do clipping here, since draw_mouse() did that already if (_overlayVisible) { uint16 *dst; uint16 *bak = (uint16 *)_mouseBackupP; TwGfxLockSurface(_overlayP, (void **)&dst); dst += _mouseOldState.y * _screenWidth + _mouseOldState.x; do { MemMove(dst, bak, _mouseOldState.w * 2); dst += _screenWidth; bak += _mouseOldState.w; } while (--h); TwGfxUnlockSurface(_overlayP, true); } else { byte *dst = _offScreenP + _mouseOldState.y * _screenWidth + _mouseOldState.x; byte *bak = _mouseBackupP; do { MemMove(dst, bak, _mouseOldState.w); dst += _screenWidth; bak += _mouseOldState.w; } while (--h); } _mouseDrawn = false; }
/******************************************************* * Function: stripCrypt * Description: encrypts/decrypts a memory block. puts * the results into an out buffer. dkey is the string * ****************************************************/ void stripCryptC(char * ikey, MemPtr str, MemPtr out, int sLen, int enc) { int offset=0; char ivector[BLOCKC], ovector[BLOCKC], k[16]; Boolean e; (enc==1)?(e=true):(e=false); //generate the key. MDString(ikey, k); xOrFold(k); //encrypt or decrypt block by block for(;offset<sLen;) { MemMove(ivector, str+offset, BLOCKC); EncDES(ivector, k, ovector, e); MemMove(out+offset, ovector, BLOCKC); offset+=BLOCKC; } // wipeout keying info. MemSet(ivector, sizeof(ivector), 0); MemSet(ovector, sizeof(ovector), 0); MemSet(k,sizeof(k), 0); }
/******************************************************* * Function: stripCrypt * Description: encrypts/decrypts a memory block. puts * the results into an out buffer. ikey is the string * ****************************************************/ void stripCryptA(char * ikey, MemPtr str, MemPtr out, int sLen, int enc) { word32 vector[3], key[3]; int offset=0; //generate the key. twKey(ikey, key); //encrypt or decrypt block by block for(;offset<sLen;) { MemMove(vector, str+offset, BLOCKA); if(enc) encrypt(vector, key); else decrypt(vector, key); MemMove(out+offset, vector, BLOCKA); offset+=BLOCKA; } // wipe out keying info. MemSet(vector, 0, sizeof(vector)); MemSet(key, 0, sizeof(key)); }
/******************************************************* * Function: stripCrypt * Description: encrypts/decrypts a memory block. puts * the results into an out buffer. ikey is the string * ****************************************************/ void stripCrypt(md5_hash * ikey, MemPtr str, MemPtr out, int sLen, int enc) { Idea_Data ivector, ovector; Idea_UserKey k; Idea_Key ekey; int offset=0; //generate the key. MemMove(k, ikey, sizeof(md5_hash)); Idea_ExpandUserKey(k, ekey); if(!enc) Idea_InvertKey(ekey, ekey); //encrypt or decrypt block by block for(;offset<sLen;) { MemMove(ivector, str+offset, BLOCK); Idea_Crypt(ivector, ovector, ekey); MemMove(out+offset, ovector, BLOCK); offset+=BLOCK; } // wipeout keying info. MemSet(ivector, sizeof(ivector), 0); MemSet(ovector, sizeof(ovector), 0); MemSet(k,sizeof(k), 0); MemSet(ekey,sizeof(ekey), 0); }
/******************************************************** * Function: twKey * Description: pass this function a null terminated * string or char array and it will generate a valid * 96 bit key for the 3-way encryption algorithm. * Method: generate the digest of the passed in string * followed by the digest for that digest. concatonate * the two arrays and get one big array of 256 bits. * Ignore the last 64 bits. take the resulting 192 bits * and fold the last 96 bits over the first 96 bits using * and XOR. i.e bit[n]^=bit[n+96]. the resulting array is * 96 bits its bit pattern is totaly dependent on the * original strings message digest. If anyone cant think * of a better way to do this, let me know. * ******************************************************/ void twKey(char * ikey, MemPtr out) { int i; char dKey[24], mdKey1[16], mdKey2[16]; // Hash the input string, hash the output, then concatonate MDString(ikey, mdKey1); MDBlock(mdKey1, 16, mdKey2); //concatanate the arrays MemMove(dKey, mdKey1, 16); MemMove(dKey+16, mdKey2, 8); //now fold dKey over itself at 96 bits, XORing as we go. for(i=0; i<12; i++) { dKey[i]^=dKey[i+BLOCKA]; } MemMove(out, dKey, BLOCKA); //wipe out keying info. MemSet(dKey,0, sizeof(dKey)); MemSet(mdKey1, 0, sizeof(mdKey1)); MemSet(mdKey2, 0, sizeof(mdKey2)); }
void sortScript() { //this saves dynamic space UInt16 i, k, size; Err err; ScriptType temp[map.numCmds]; //get rid of all map cmds for(i = 0; i < map.numCmds; i++) { if(!cmdIsAI(script[i].type)) { //copy next cmd into this one if there is for(k = i; k < map.numCmds;k++) { //if there is a cmd left if(k != (map.numCmds - 1)) { //if it still isn't ai then continue if(!cmdIsAI(script[k + 1].type)) { continue; } else { //copy it into new, discard old MemMove(&temp[i], &script[k + 1], sizeof(ScriptType)); size++; //get out of loop break; } } } } //leave it if it is an ai } //resize script to value of size err = MemHandleResize(scriptH, sizeof(ScriptType) * size); if(err == memErrChunkLocked) { //unlock MemHandleUnlock(scriptH); if(err = MemHandleResize(scriptH, sizeof(ScriptType) * size)) { ErrFatalDisplay("In sortscript, couldn't resize script"); } script = (ScriptType *)MemHandleLock(scriptH); } else if(err != 0) { //some other error ErrFatalDisplay("In sortscript, couldn't resize script"); } //move all script into new one MemMove(script, &temp, sizeof(ScriptType) * size); }
/* ** Load the record data (flags, ...) - but not the picture */ static void LoadRecordData(void) { MemHandle t = NULL; MemPtr ptr = NULL; UInt16 attr = 0; UInt32 highDataOffset = 0; Int16 len = 0; PRINT("Loading Record Data for %hd", p.dbI); /* Clear unmasked flag */ d.unmaskedCurrentRecord = false; /* Open and lock the record */ t = DmQueryRecord(d.dbR, p.dbI); if (!t) abort(); ptr = MemHandleLock(t); /* Is the record private? */ DmRecordInfo(d.dbR, p.dbI, &attr, NULL, NULL); d.record_private = attr & dmRecAttrSecret; /* Read the header data */ MemMove(&d.record, ptr, sizeof(DiddleBugRecordType)); /* Read the additional alarm info */ highDataOffset = sketchDataOffset + d.record.sketchLength; len = StrLen((Char*)(ptr + highDataOffset)) + 1; /* +1 for null char */ if (d.record_name) MemHandleFree(d.record_name); d.record_name = MemHandleNew(len); ASSERT(d.record_name); MemMove(MemHandleLock(d.record_name), ptr + highDataOffset, len); MemHandleUnlock(d.record_name); highDataOffset += len; len = StrLen((Char*)(ptr + highDataOffset)) + 1; /* +1 for null char */ if (d.record_note) MemHandleFree(d.record_note); d.record_note = MemHandleNew(len); ASSERT(d.record_note); MemMove(MemHandleLock(d.record_note), ptr + highDataOffset, len); MemHandleUnlock(d.record_note); highDataOffset += len; /* Clear old data since there may not be an extra-data block yet */ MemSet(&d.record_sound, sizeof(AlarmSoundInfoType), 0); d.record_sound.listIndex = -1; /* default */ /* Read new extra-data (if it exists and is from a compatible version) */ if (d.record.extraLength == sizeof(AlarmSoundInfoType)) MemMove(&d.record_sound, ptr + highDataOffset, d.record.extraLength); /* Unlock record */ MemHandleUnlock(t); }
/************************************************************************** * Function: generateAccountHash * Description: returns the unique hash for the account. * ************************************************************************/ md_hash * generateAccountHash (Account * acct) { static md_hash ret; unsigned char * hashable; int data_length = 0, string_length = 0; MemSet(ret, sizeof(md_hash), 0); /* username, password, acct mod date, * pw mod date, and 256 bits of randomness */ data_length = StrLen(acct->username)+ StrLen(acct->system)+ StrLen(acct->password)+ StrLen(acct->service)+ StrLen(acct->comment)+ sizeof(acct->account_mod_date)+ sizeof(acct->password_mod_date)+ (sizeof(Int16)*16)+1; if((hashable=MemPtrNew(data_length))) { MemSet(hashable, data_length, 0); StrCopy(hashable, acct->username); string_length+=StrLen(acct->username); StrCat(hashable, acct->system); string_length+=StrLen(acct->system); StrCat(hashable, acct->password); string_length+=StrLen(acct->password); StrCat(hashable, acct->service); string_length+=StrLen(acct->service); StrCat(hashable, acct->comment); string_length+=StrLen(acct->comment); MemMove(hashable+string_length, &acct->account_mod_date, sizeof(acct->account_mod_date)); string_length+=sizeof(acct->account_mod_date); MemMove(hashable+string_length, &acct->password_mod_date, sizeof(acct->password_mod_date)); string_length+=sizeof(acct->password_mod_date); /* move some randomness onto the end * to make dictionary attacks impossible. */ random_bytes(hashable+string_length, 32); string_length+=32; md_block(hashable, string_length, ret); MemPtrFree(hashable); } return &ret; }
/* Handle the Gesture preferences */ Boolean PrefsGesturePreferenceEvent ( ActionType action ) { Boolean handled; handled = false; switch ( action ) { case AVAILABLE: /* Always available */ handled = true; break; case SHOWFIRST: handled = showFirst; showFirst = false; break; case LOAD: gestureSelected = GESTURES_UP; MemMove( gestureMode, Prefs()->gestMode, sizeof( gestureMode ) ); InitializeActionList( frmPrefsGestureActionList ); CtlSetValue( GetObjectPtr( frmPrefsGestureGestures ), Prefs()->gestures ); SetListToSelection( frmPrefsGestureActionList, frmPrefsGestureSelectAction, gestureMode[ gestureSelected ] ); handled = true; break; case DISPLAY: AffirmControlImage( gestureSelected, frmPrefsGestureUp, bmpGestureUp ); handled = true; break; case SAVE: Prefs()->gestures = CtlGetValue( GetObjectPtr( frmPrefsGestureGestures ) ); MemMove( Prefs()->gestMode, gestureMode, sizeof( gestureMode ) ); handled = true; break; default: handled = false; break; } return handled; }
/************************************************************************************ * Function: UnpackAccountA * Description: This is a utility function that will take a packed account , * optionally decrypt it based on the passed in password, and set up * an unpacked account. isRec determines whether the packed account is a full record. * remember that fullrecords have the plaintext system id prepended, so if it * is a full record we will ignore this space. * **********************************************************************************/ static void UnpackAccount_old (Account_old * acct, MemPtr p, MemPtr scratch, char *pass, UInt16 recLen, Boolean decrypt, Boolean isRec, int v) { PAccount_old * pacct; char *s; UInt16 offset = sizeof (offset); recLen = recLen - offset; // decrypt if neccessary if (decrypt) switch (v) { case 0: stripCrypt_tw (pass, p + offset, scratch, recLen, 0); break; case 1: stripCrypt_idea (pass, p + offset, scratch, recLen, 0); break; case 2: stripCrypt_des (pass, p + offset, scratch, recLen, 0); break; } else // if buffer has the systemID header disregard it. if (isRec) MemMove (scratch, p + offset, recLen); else MemMove (scratch, p, recLen); // split record up into its different components. pacct = (PAccount_old *) scratch; s = pacct->username; acct->SystemID = pacct->SystemID; acct->AccountID = pacct->AccountID; acct->username = s; s += StrLen (s) + 1; acct->password = s; s += StrLen (s) + 1; acct->type = s; s += StrLen (s) + 1; acct->comment = s; s += StrLen (s) + 1; }
static Char * PrvAddPadding(Char * startOfBlock, Char * dstP, const Int16 minimumSize, const Boolean leftJustify, Boolean zeroPad, Char sign) { Int16 stringSize = StrLen(startOfBlock); ErrNonFatalDisplayIf( sign && (sign != '+') && (sign != ' '), "illegal sign character specified in PrvAddPadding" ); if (leftJustify && stringSize < minimumSize) // Left Justified { MemSet(dstP, minimumSize - stringSize, ' '); dstP += minimumSize - stringSize; *dstP = '\0'; } else if (!leftJustify && stringSize < minimumSize) // Right Justified { // If there is a sign present and the calling function as specified padding with // zero bytes then do not move the sign character with the rest of the value. if ( (sign == '+' || sign == ' ') && zeroPad ) { // If there is a sign present then only MemMove the value and not the sign. // The value will be moved minimum size specified for this value minus the // actual string size of the value plus the size of the sign (1). MemMove(startOfBlock + minimumSize - stringSize + 1, startOfBlock + 1, stringSize - 1); // MemSet the space between the sign and moved value with the desired // padding value. MemSet(startOfBlock + 1, minimumSize - stringSize, zeroPad ? '0' : ' '); } else { // MemMove the value and any potential sign character to make room for padding // characters. The number of bytes to move is determined by the minimum string // specified for the value minus the actual string size of the value. MemMove(startOfBlock + minimumSize - stringSize, startOfBlock, stringSize); // MemSet the space between the sign and moved value with the desired // padding value. MemSet(startOfBlock, minimumSize - stringSize, zeroPad ? '0' : ' '); } dstP += minimumSize - stringSize; *dstP = '\0'; } return dstP; }
void deserData(unsigned char *valOut, int len, const unsigned char **data, long *pBlobSizeLeft) { Assert( data && *data && pBlobSizeLeft && (*pBlobSizeLeft>=len) ); MemMove( valOut, *data, len ); *data = *data+len; *pBlobSizeLeft -= len; }
/************************************************************************************ * Function: UnpackSystem_old * Description: This is a utility function that will take a packed System , * optionally decrypt it based on the passed in password, and set up * an unpacked system. * **********************************************************************************/ static void UnpackSystem_old (System_old * sys, MemPtr p, MemPtr scratch, char *pass, UInt16 recLen, Boolean decrypt, int v) { PSystem_old * psys; char *s; // if necessary, decrypt, otherwise just copy the memory to the scratch buffer if (decrypt) switch (v) { case 0: stripCrypt_tw (SysPass, p, scratch, recLen, 0); break; case 1: stripCrypt_idea (SysPass, p, scratch, recLen, 0); break; case 2: stripCrypt_des (SysPass, p, scratch, recLen, 0); break; } else MemMove (p, scratch, recLen); // set up the system, pointing the name to the first char in the name string. psys = (PSystem_old *) scratch; s = psys->name; sys->SystemID = psys->SystemID; sys->name = s; s += StrLen (s) + 1; }
void* PrvRealloc(void* p, UInt32 newSize) { if (0 == newSize) { if (NULL != p) MemPtrFree(p); return NULL; } newSize = PrvBlockSize(newSize); if (NULL == p) return MemGluePtrNew(newSize); UInt32 size = MemPtrSize(p); if (newSize <= size) return p; Err err = MemPtrResize(p, newSize); if (errNone == err) return p; void* np = MemGluePtrNew(newSize); if (NULL != np) MemMove(np, p, size); MemPtrFree(p); return np; }
static void ModSetStack(UInt32 newSize, UInt16 cardNo, LocalID dbID) { DmOpenRef dbRef = DmOpenDatabase(cardNo, dbID, dmModeReadWrite); if (dbRef) { MemHandle pref = DmGetResource('pref',0); UInt32 size = 0; if (pref) { SysAppPrefsType *data = (SysAppPrefsType *)MemHandleLock(pref); size = data->stackSize; if (newSize) { SysAppPrefsType newData; MemMove(&newData, data, sizeof(SysAppPrefsType)); newData.stackSize = newSize; DmWrite(data, 0, &newData, sizeof(SysAppPrefsType)); } MemPtrUnlock(data); DmReleaseResource(pref); } DmCloseDatabase(dbRef); } }
static void /*FCN*/OnFeatMove ( ButtoN b ){ Int2 i,j,k; Int2 movFeat; movFeat = featAr[curFeatureInd]; i = GetValue ( featPopup ); if ( groupAr[curGroupInd] <= i ) i++; MemMove ( &(featAr[curFeatureInd]), &(featAr[curFeatureInd+1]), (totalFeatures - curFeatureInd - 1)*sizeof(Int2) ); if ( curFeatureInd >= nHideFeatures ){ Nlm_SetMuskCParamEd(movFeat,MSM_FGROUP,MSM_NUM,(BigScalar)i); } else { nHideFeatures--; for ( j=1; j<=MSM_TOTAL_POSITIVE; j++ ){ if ( (Int2)Nlm_GetMuskCParamEd(j,MSM_FGROUP,MSM_NUM ) == i ){ k = (Int2)Nlm_GetMuskCParamEd(j,MSM_FORDER,MSM_NUM ); if ( k > 0 ){ Nlm_SetMuskCParamEd(j,MSM_FORDER,MSM_NUM,(BigScalar)(k+1)); } } } Nlm_SetMuskCParamEd(movFeat,MSM_FGROUP,MSM_NUM,(BigScalar)i); Nlm_SetMuskCParamEd(movFeat,MSM_FORDER,MSM_NUM,1); } totalFeatures--; if ( curFeatureInd == totalFeatures ) curFeatureInd--; FillFeatList(TRUE); SetFeatValue ( curFeatureInd ); SaveFeatureArray(); UpdateDlgControls(); }
static void /*FCN*/OnGroupNew ( ButtoN b ){ Int2 i; Char newName[64]; GetTitle ( groupDialog, &(newName[0]), 64 ); if ( newName[0] == 0 ) return; newName[63] = 0; for ( i=1; i<=totalGroups; i++ ){ if ( StringCmp ( (CharPtr)Nlm_GetMuskCParamEd(MSM_GROUPS, i,MSM_STRING), &(newName[0]) ) == 0 ) return; } MemMove ( &(groupAr[1]), &(groupAr[0]), totalGroups*sizeof(Int2) ); totalGroups++; nHideGroups++; groupAr[0] = totalGroups; Nlm_SetMuskCParamEd(MSM_GROUPS,MSM_NOSUBCLASS,MSM_NUM,(BigScalar)totalGroups); Nlm_SetMuskCParamEd(MSM_GROUPS,totalGroups,MSM_STRING,(BigScalar)&(newName[0])); curGroupInd = 0; FillGroupList(TRUE); SetGroupValue ( curGroupInd ); FillFeatPopup(TRUE); LoadFeatureArray(); FillFeatList(TRUE); if ( totalFeatures == 0 ){ curFeatureInd = -1; } else { curFeatureInd = 0; SetFeatValue ( curFeatureInd ); } UpdateDlgControls(); SaveGroupArray(); }
XPTEXP1 void * XPTAPI XPTEXP2 xppRealloc(void *ptr, size_t size) { Err rc; UInt32 currentSize; void *newMem; /* If original pointer is null, act like a normal malloc */ if (!ptr) return MemPtrNew(size); /* Try resizing original area. This will always work if the new area */ /* is smaller. It may or may not work if growing the area. */ rc = MemPtrResize(ptr, size); if (!rc) return ptr; /* It worked. Return same pointer. */ /* Resizing didn't work. Allocate a new, larger, area, and copy the */ /* previous data from the old area. */ newMem = MemPtrNew(size); if (!newMem) return newMem; /* Pass error to caller */ /* The original size must be smaller than the new size */ currentSize = MemPtrSize(ptr); MemMove(newMem, ptr, currentSize); /* Release the old area. */ MemPtrFree(ptr); return newMem; }
/* remove an item from the list and move te rest one position up */ static Int16 RemoveFileRec(FileRef fr) { Int16 i; Err ret; file_rec_t* axxFileList; axxPacFD FileDesc; axxFileList = MemHandleLock(axxFileListHandle); i = GetFilePos((Int16)fr); if (i == -1) return -1; FileDesc=axxFileList[i].fd; for (; i < axxFLSize - 1; i++) { MemMove (&axxFileList[i], &axxFileList[i + 1],sizeof(axxFileList)); } axxFLSize--; ret = MemHandleResize(axxFileListHandle, sizeof(file_rec_t) * axxFLSize); ret = MemHandleUnlock(axxFileListHandle); /* Check if the current file is the one removed from the list */ if ((currFileDesc != -1) && ( FileDesc== currFileDesc)) { /* the cache of offsets is no longer valid if this file was closed */ currFileDesc = -1; MemHandleFree(moff); } return 0; }
static void NewAddrUnpack(PrvAddrPackedDBRecord *src, AddrDBRecordPtr dest) { Int16 index; AddrDBRecordFlags flags; char *p; MemMove(&(dest->options), &(src->options), sizeof(AddrOptionsType)); MemMove(&flags, &(src->flags), sizeof(AddrDBRecordFlags)); p = &src->firstField; for (index = firstAddressField; index < addrNumStringFields; index++) { // If the flag is set, point to the string else NULL if (GetBitMacro(flags, index) != 0) { dest->fields[index] = p; p += StrLen(p) + 1; } else dest->fields[index] = NULL; } // Unpack birthday info MemSet(&(dest->birthdayInfo), sizeof(BirthdayInfo), 0 ); if(GetBitMacro(flags, birthdayDate)) { MemMove(&(dest->birthdayInfo.birthdayDate), p, sizeof(DateType)); p += sizeof(DateType); } if(GetBitMacro(flags, birthdayMask)) { MemMove(&(dest->birthdayInfo.birthdayMask), p, sizeof(AddressDBBirthdayFlags)); //Dest->birthdayInfo.birthdayMask = *((AddressDBBirthdayFlags*)p); p += sizeof(AddressDBBirthdayFlags); } if(GetBitMacro(flags, birthdayPreset)) { dest->birthdayInfo.birthdayPreset = *((UInt8*)p); p += sizeof(UInt8); } // Ignore the blob part - I don't use it }
void GenMatchedRule(Rule * rule) { Var rule_proc; Var * args[MACRO_ARG_CNT]; rule_proc.instr = rule->to; MemMove(args, MACRO_ARG, sizeof(args)); GenMacro(&rule_proc, args); }
/************************************************************************************ * Function: PackRegistration * Description: Utility function that takes an unpacked Registration, optionally encrypts * it and packs it into a buffer, strings are seperated by null characters. puts the * content in retbuffer * *********************************************************************************/ void PackRegistration (MemPtr retbuff, Registration reg) { UInt16 offset = 0; MemPtr preg; if ((preg = MemPtrNew (MemPtrSize (retbuff)))) { /* move the data into the buffer. */ MemMove (preg + offset, ®.first_use, sizeof (reg.first_use)); offset += sizeof (reg.first_use); MemMove (preg + offset, reg.email, StrLen (reg.email) + 1); offset += StrLen (reg.email) + 1; MemMove (preg + offset, reg.code, StrLen (reg.code) + 1); offset += StrLen (reg.code) + 1; MemMove (retbuff, preg, MemPtrSize(preg)); MemSet (preg, MemPtrSize (preg), 0); MemPtrFree (preg); } }
/************************************************************************************ * Function: UnpackSystem * Description: This is a utility function that will take a packed System , * optionally decrypt it based on the passed in password, and set up * an unpacked system. * **********************************************************************************/ void UnpackSystem (System * sys, MemPtr p, MemPtr scratch, md_hash * pass, UInt16 recLen, Boolean decrypt) { PSystem * psys; char *s; /* if necessary, decrypt, otherwise just copy the memory to the scratch buffer */ if (decrypt) { MemMove(scratch, p, SYST_HEADER); stripCrypt (*pass, (p+SYST_HEADER), (scratch+SYST_HEADER), (recLen-SYST_HEADER), DECRYPT); } else MemMove (p, scratch, recLen); /* set up the system, pointing the name to the first char in the name string. */ psys = (PSystem *) scratch; s = psys->name; sys->SystemID = psys->SystemID; sys->name = s; s += StrLen (s) + 1; }
/*********************************************************************************** * Function: PackPassword * Description: pack a password and encrypt it using spass * *********************************************************************************/ void PackPassword (MemPtr retbuff, md_hash * spass) { MemPtr ppass; if ((ppass = MemPtrNew (getSCSize(sizeof(md_hash))))) { MemMove (ppass, spass, sizeof (md_hash)); stripCrypt (*spass, ppass, retbuff, getSCSize(sizeof(md_hash)), ENCRYPT); MemSet (ppass, MemPtrSize (ppass), 0); MemPtrFree (ppass); } }
/****************************************************************************** * Function: getSIDForSystemIndex * Description: this will get the system id for a given index in the * system database. * ****************************************************************************/ UInt16 getSIDForSystemIndex (DmOpenRef SystemDB, UInt16 i) { UInt16 ret; MemHandle rec = DmQueryRecord (SystemDB, i); if (rec) { MemPtr buff = MemHandleLock (rec); MemMove (&ret, buff, sizeof (ret)); MemHandleUnlock (rec); } return ret; }
int load_preferences(void) {UInt16 prefs_size=0;int version,n;char*p,*_; version=PrefGetAppPreferences(CREATOR,prefs_id,0,&prefs_size,0); if(version!=prefs_version)return try_db_name(); if(prefs_size<db_name_size+1)return try_db_name(); p=MemPtrNew(prefs_size);if(!p)return try_db_name();_=p; version=PrefGetAppPreferences(CREATOR,prefs_id,p,&prefs_size,0); if(version!=prefs_version){MemPtrFree(p);return try_db_name();} n=db_name_size;MemMove(db_name,_,n);_+=n;prefs_size-=n;db_name[n]=0; if(try_db_name())return!0; if(prefs_size>1) {n=StrLen(_)+1;lookup=MemPtrNew(n); if(lookup)MemMove(lookup,_,n);prefs_size-=n;_+=n; }if(prefs_size>0) {char aux_flags=*_;set_list_mode(2*!!(aux_flags&(1<<list_mode_bit))); prefs_size-=1;_+=1; }MemPtrFree(p);return 0; }static int
/************************************************************************************ * Function: PackSystem * Description: Utility function that takes an unpacked system, optionally encrypts * it and packs it into a buffer, strings are seperated by null characters. puts the * content in retbuffer * *********************************************************************************/ void PackSystem (MemPtr retbuff, System sys, md_hash * pass, Boolean encrypt) { UInt16 offset = 0; MemPtr psys; if ((psys = MemPtrNew (MemPtrSize (retbuff)))) { /* move the data into the buffer. */ MemMove (psys + offset, &sys.SystemID, sizeof (sys.SystemID)); offset += sizeof (sys.SystemID); MemMove (psys + offset, sys.name, StrLen (sys.name) + 1); offset += StrLen (sys.name) + 1; if (encrypt) { MemMove(retbuff, psys, SYST_HEADER); stripCrypt (*pass, psys+SYST_HEADER, retbuff+SYST_HEADER, getSystemSize(&sys, true)-SYST_HEADER, ENCRYPT); } else MemMove (retbuff, psys, getSystemSize (&sys, true)); MemSet (psys, MemPtrSize (psys), 0); MemPtrFree (psys); } }
/************************************************************************** * Function: getAIDFromAccountIndex * Description: returns the account id for the account located at a given * index. Remember that the first few bytes of an account record are the * system ID of the account. Just skip these an pop off the AID. * ************************************************************************/ UInt16 getAIDFromAccountIndex(DmOpenRef AccountDB, UInt16 index) { UInt16 ret = 0; MemHandle rec = DmQueryRecord (AccountDB, index); if (rec) { MemPtr buff = MemHandleLock (rec); MemMove (&ret, buff+sizeof(ret), sizeof (ret)); MemHandleUnlock (rec); } return ret; }
/************************************************************************** * Function: getHashFromAccountIndex * Description: returns the unique has for the account located at a given * index. Remember that the first few bytes of an account record are the * system ID of the account. Just skip these an pop off the AID. * ************************************************************************/ md_hash * getHashFromAccountIndex (DmOpenRef AccountDB, UInt16 index) { static md_hash ret; MemHandle rec = DmQueryRecord (AccountDB, index); if (rec) { MemPtr buff = MemHandleLock (rec); MemMove (ret, buff+sizeof(UInt16)+sizeof(UInt16), sizeof (ret)); MemHandleUnlock (rec); } return &ret; }