//================================================================================================= axCharA axDataBufferReader::ReadCharA() { axCharA cResultA; ReadBytes((axBytes)&cResultA, axSizeOf(axCharA)); return cResultA; }
/* if we can't determine it, we will return true */ static int is_gui_app (char *exe) { HANDLE hImage; DWORD bytes; DWORD iSection; DWORD SectionOffset; DWORD CoffHeaderOffset; DWORD MoreDosHeader[16]; CHAR *file; size_t nlen; ULONG ntSignature; IMAGE_DOS_HEADER image_dos_header; IMAGE_FILE_HEADER image_file_header; IMAGE_OPTIONAL_HEADER image_optional_header; IMAGE_SECTION_HEADER image_section_header; /* * Open the reference file. */ nlen = strlen (exe); file = exe; if (nlen > 2) { if (exe[0] == '"') { /* remove quotes */ nlen -= 2; file = malloc ((nlen + 1) * sizeof (char)); memcpy (file, &exe[1], nlen); file [nlen] = '\0'; } } hImage = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (file != exe) { free (file); } if (INVALID_HANDLE_VALUE == hImage) { report_file_error ("Could not open exe: ", Qnil); report_file_error (exe, Qnil); report_file_error ("\n", Qnil); CloseHandle (hImage); return -1; } /* * Read the MS-DOS image header. */ ReadBytes(hImage, &image_dos_header, sizeof(IMAGE_DOS_HEADER)); if (IMAGE_DOS_SIGNATURE != image_dos_header.e_magic) { report_file_error("Sorry, I do not understand this file.\n", Qnil); CloseHandle (hImage); return -1; } /* * Read more MS-DOS header. */ ReadBytes(hImage, MoreDosHeader, sizeof(MoreDosHeader)); /* * Get actual COFF header. */ CoffHeaderOffset = AbsoluteSeek(hImage, image_dos_header.e_lfanew) + sizeof(ULONG); if (CoffHeaderOffset < 0) { CloseHandle (hImage); return -1; } ReadBytes (hImage, &ntSignature, sizeof(ULONG)); if (IMAGE_NT_SIGNATURE != ntSignature) { report_file_error ("Missing NT signature. Unknown file type.\n", Qnil); CloseHandle (hImage); return -1; } SectionOffset = CoffHeaderOffset + IMAGE_SIZEOF_FILE_HEADER + IMAGE_SIZEOF_NT_OPTIONAL_HEADER; ReadBytes(hImage, &image_file_header, IMAGE_SIZEOF_FILE_HEADER); /* * Read optional header. */ ReadBytes(hImage, &image_optional_header, IMAGE_SIZEOF_NT_OPTIONAL_HEADER); CloseHandle (hImage); switch (image_optional_header.Subsystem) { case IMAGE_SUBSYSTEM_UNKNOWN: return 1; break; case IMAGE_SUBSYSTEM_NATIVE: return 1; break; case IMAGE_SUBSYSTEM_WINDOWS_GUI: return 1; break; case IMAGE_SUBSYSTEM_WINDOWS_CUI: return 0; break; case IMAGE_SUBSYSTEM_OS2_CUI: return 0; break; case IMAGE_SUBSYSTEM_POSIX_CUI: return 0; break; default: /* Unknown, return GUI app to be preservative: if yes, it will be correctly launched, if no, it will be launched, and a console will be also displayed, which is not a big deal */ return 1; break; } }
int16 ModVDMX(CONST_TTFACC_FILEBUFFERINFO * pInputBufferInfo, TTFACC_FILEBUFFERINFO * pOutputBufferInfo, CONST uint16 usFormat, uint32 *pulNewOutOffset) { VDMX Vdmx; uint32 ulSrcOffset; /* offset to Src VDMX table */ uint32 ulSrcLength; /* length of Src VDMX table */ uint32 ulDestOffset; /* offset to Dest VDMX table */ uint32 ulDestLength; /* length of Dest VDMX table */ uint32 ulSrcOffsetRatios; /* absolute offset to Ratios in Src file */ uint32 ulSrcOffsetOffsets; /* absolute offset to Offsets in Src file */ uint32 ulSrcOffsetGroups; /* absolute offset to Groups in Src file */ uint32 ulDestOffsetRatios; /* absolute offset to Ratios in Dest file */ uint32 ulDestOffsetOffsets; /* absolute offset to Offsets in Dest file */ uint32 ulDestOffsetGroups; /* absolute offset to Groups in Dest file */ uint16 usCurrGroupSrcOffset; /* relative offset from beginning of VDMX table */ uint16 usCurrGroupDestOffset; /* relative offset from beginning of VDMX table */ uint32 ulCurrGroupDestOffset=0; /* relative offset from beginning of VDMX table - long value */ uint16 usGroupDestOffset; /* relative offset from beginning of VDMX table, local copy for writing */ uint16 ----cRatioIndex,usDestRatioIndex; uint16 i; uint16 usBytesRead; uint16 usBytesWritten; uint32 ulBytesRead; int16 errCode=NO_ERROR; VDMXRatio *SrcRatioArray=NULL; int8 *KeepSrcRatioArray = NULL; /* parallel array to SrcRatioArray */ VDMXGroup GroupHeader; uint8 * pGroupBuffer=NULL; uint32 ulGroupBufferLength; /* total length of the Group Buffer (from source file) */ uint32 ulGroupLength; /* length of individual group to be read */ uint16 usGroupCount = 0; uint16 usKeepRatioCount = 0; uint16 usRatioSize; uint16 xRatio, yRatio; /* for reducing the ratios */ int16 Found1to1; GROUPOFFSETRECORDKEEPER keeper; TTFACC_FILEBUFFERINFO * pUnCONSTInputBufferInfo; if (usFormat == TTFDELTA_DELTA) /* only formats for which this is not valid */ { MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG); return errCode; } pUnCONSTInputBufferInfo = (TTFACC_FILEBUFFERINFO *) pInputBufferInfo; /* used for Read functions ONLY. Not for Write */ /* get input buffer information */ ulSrcOffset = TTTableOffset( pUnCONSTInputBufferInfo, VDMX_TAG ); if ( ulSrcOffset == 0L ) return NO_ERROR; ulSrcLength = TTTableLength( pUnCONSTInputBufferInfo, VDMX_TAG ); if ( ulSrcLength == 0L ) { MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG); return NO_ERROR; } /* get output buffer information */ if ((errCode = ZeroLongWordAlign(pOutputBufferInfo, *pulNewOutOffset, &ulDestOffset)) != NO_ERROR) return errCode; if ((errCode = ReadGeneric( pUnCONSTInputBufferInfo, (uint8 *) &Vdmx, SIZEOF_VDMX, VDMX_CONTROL, ulSrcOffset, &usBytesRead )) != NO_ERROR) return errCode; if (Vdmx.numRatios == 0) { MarkTableForDeletion(pOutputBufferInfo, VDMX_TAG); return NO_ERROR; } ulSrcOffsetRatios = ulSrcOffset + usBytesRead; ulSrcOffsetOffsets = ulSrcOffsetRatios + GetGenericSize(VDMXRATIO_CONTROL) * Vdmx.numRatios; ulSrcOffsetGroups = ulSrcOffsetOffsets + sizeof(uint16) * Vdmx.numRatios; memset(&keeper, 0, sizeof(keeper)); SrcRatioArray = (VDMXRatio *)Mem_Alloc(Vdmx.numRatios * sizeof(VDMXRatio)); if (SrcRatioArray == NULL) errCode = ERR_MEM; else { KeepSrcRatioArray = (int8 *)Mem_Alloc(Vdmx.numRatios * sizeof(int8)); if (KeepSrcRatioArray == NULL) errCode = ERR_MEM; else errCode = ReadGenericRepeat(pUnCONSTInputBufferInfo, (uint8 *) SrcRatioArray, VDMXRATIO_CONTROL, ulSrcOffsetRatios, &ulBytesRead, Vdmx.numRatios, SIZEOF_VDMXRATIO ); } while (errCode == NO_ERROR) /* while is so we can break out. Only go once through */ { Found1to1 = FALSE; for (i = 0; i < Vdmx.numRatios ; ++i) /* keep all 1:1 aspect ratios */ { KeepSrcRatioArray[i] = 1; /* assume we'll keep it */ xRatio = SrcRatioArray[i].xRatio; yRatio = SrcRatioArray[i].yStartRatio; ReduceRatio(&xRatio,&yRatio); if (xRatio == yRatio) { if (SrcRatioArray[i].xRatio == 0) /* anything after 0:0 is ignored */ { if (!Found1to1) /* need to keep this one */ ++usKeepRatioCount; break; } if (Found1to1) /* already have one */ KeepSrcRatioArray[i] = 0; /* don't keep this one */ else { Found1to1 = TRUE; ++usKeepRatioCount; } } else if (xRatio == EGA_X_RATIO && yRatio == EGA_Y_RATIO) KeepSrcRatioArray[i] = 0; /* don't keep this one */ else ++usKeepRatioCount; } if ((usKeepRatioCount == 0) || (usKeepRatioCount == Vdmx.numRatios)) { /* don't change a thing */ Mem_Free(SrcRatioArray); Mem_Free(KeepSrcRatioArray); return CopyTableOver(pOutputBufferInfo, pInputBufferInfo, VDMX_TAG, pulNewOutOffset); } ulDestOffsetRatios = ulDestOffset + usBytesRead; /* figure out offset for the Offset array */ ulDestOffsetOffsets = ulDestOffsetRatios + GetGenericSize(VDMXRATIO_CONTROL) * usKeepRatioCount; ulDestOffsetGroups = ulDestOffsetOffsets + sizeof(uint16) * usKeepRatioCount; usRatioSize = GetGenericSize(VDMXRATIO_CONTROL); ulCurrGroupDestOffset = ulDestOffsetGroups - ulDestOffset; /* calculate offset from start of VDMX table */ if ((errCode = InitGroupOffsetArray(&keeper,usKeepRatioCount)) != NO_ERROR) /* initialize structure to track offset re-use */ break; ulGroupBufferLength = ulSrcLength - (ulSrcOffsetGroups - ulSrcOffset); /* calculate the length of the group section */ pGroupBuffer = (uint8 *)Mem_Alloc(ulGroupBufferLength); /* allocate buffer the size of the group buffer */ if (pGroupBuffer == NULL) { errCode = ERR_MEM; break; } for (----cRatioIndex = usDestRatioIndex = 0; ----cRatioIndex < Vdmx.numRatios && usDestRatioIndex < usKeepRatioCount; ++----cRatioIndex) /* keep all 1:1 aspect ratios */ { if (KeepSrcRatioArray[----cRatioIndex] == 1) { /* write out the Ratio to the proper location */ if ((errCode = WriteGeneric(pOutputBufferInfo, (uint8 *) &(SrcRatioArray[----cRatioIndex]), SIZEOF_VDMXRATIO, VDMXRATIO_CONTROL, ulDestOffsetRatios + (usDestRatioIndex * usRatioSize), &usBytesWritten)) != NO_ERROR) break; /* now read the offset to the group */ if ((errCode = ReadWord(pUnCONSTInputBufferInfo, &usCurrGroupSrcOffset, ulSrcOffsetOffsets + (----cRatioIndex * sizeof(uint16)) )) != NO_ERROR) break; /* check if offset already used */ if ((usGroupDestOffset = LookupGroupOffset(&keeper, usCurrGroupSrcOffset)) == 0) /* not there already */ { if (ulCurrGroupDestOffset > USHRT_MAX) /* check if will fit in unsigned short */ { errCode = ERR_INVALID_VDMX; break; } usCurrGroupDestOffset = (uint16) ulCurrGroupDestOffset; /* already checked if in range */ /* need to register the old and new group offsets */ if ((errCode = RecordGroupOffset(&keeper, usCurrGroupSrcOffset, usCurrGroupDestOffset)) != NO_ERROR) break; usGroupDestOffset = usCurrGroupDestOffset; /* need to copy the group data over */ if ((errCode = ReadGeneric(pUnCONSTInputBufferInfo, (uint8 *) &GroupHeader, SIZEOF_VDMXGROUP, VDMXGROUP_CONTROL, ulSrcOffset + usCurrGroupSrcOffset, &usBytesRead)) != NO_ERROR) break; ulGroupLength = usBytesRead + (GroupHeader.recs * GetGenericSize(VDMXVTABLE_CONTROL)); /* read the group data into a buffer */ if (ulGroupLength > ulGroupBufferLength) { errCode = ERR_INVALID_VDMX; /* error in data! */ break; } if ((errCode = ReadBytes(pUnCONSTInputBufferInfo, (uint8 *) pGroupBuffer, ulSrcOffset + usCurrGroupSrcOffset, ulGroupLength)) != NO_ERROR) break; /* and write them to the output buffer */ if ((errCode = WriteBytes(pOutputBufferInfo, (uint8 *) pGroupBuffer, ulDestOffset + usCurrGroupDestOffset, ulGroupLength)) != NO_ERROR) break; ++usGroupCount; /* increment our CurrGroupDestOffset value for next time around */ ulCurrGroupDestOffset = usCurrGroupDestOffset + ulGroupLength; } /* now write out that relative offset value */ if ((errCode = WriteWord(pOutputBufferInfo, usGroupDestOffset, ulDestOffsetOffsets + (usDestRatioIndex * sizeof(uint16)))) != NO_ERROR) break; ++usDestRatioIndex; /* increment in dest array */ } } break; /* out of while */ } if (errCode == NO_ERROR) { Vdmx.numRatios = usKeepRatioCount; Vdmx.numRecs = usGroupCount; errCode = WriteGeneric( pOutputBufferInfo, (uint8 *) &Vdmx, SIZEOF_VDMX, VDMX_CONTROL, ulDestOffset, &usBytesWritten ); } if (errCode == NO_ERROR) { ulDestLength = ulCurrGroupDestOffset; /* this is the size of the table */ errCode = UpdateDirEntryAll( pOutputBufferInfo, VDMX_TAG, ulDestLength, ulDestOffset ); *pulNewOutOffset = ulDestOffset + ulDestLength; } FreeGroupOffsetArray(&keeper); /* free up structure to track offset re-use */ Mem_Free(pGroupBuffer); Mem_Free(KeepSrcRatioArray); Mem_Free(SrcRatioArray); return errCode; }
void AuthSocket::HandleProof() { if(!m_account || !HasBytes(sizeof(sAuthLogonProof_C))) return ; sLog.outDebug("[AuthLogonProof] Interleaving and checking proof..."); sAuthLogonProof_C lp; ReadBytes((u8*)&lp, sizeof(sAuthLogonProof_C)); BigNumber A; A.SetBinary(lp.A, 32); Sha1Hash sha; sha.UpdateBigNumbers(&A, &B, 0); sha.Finalize(); BigNumber u; u.SetBinary(sha.GetDigest(), 20); BigNumber S = (A * (v.ModExp(u, N))).ModExp(b, N); uint8 t[32]; uint8 t1[16]; uint8 vK[40]; memcpy(t, S.AsByteArray(), 32); for (int i = 0; i < 16; i++) { t1[i] = t[i*2]; } sha.Initialize(); sha.UpdateData(t1, 16); sha.Finalize(); for (int i = 0; i < 20; i++) { vK[i*2] = sha.GetDigest()[i]; } for (int i = 0; i < 16; i++) { t1[i] = t[i*2+1]; } sha.Initialize(); sha.UpdateData(t1, 16); sha.Finalize(); for (int i = 0; i < 20; i++) { vK[i*2+1] = sha.GetDigest()[i]; } m_sessionkey.SetBinary(vK, 40); uint8 hash[20]; sha.Initialize(); sha.UpdateBigNumbers(&N, NULL); sha.Finalize(); memcpy(hash, sha.GetDigest(), 20); sha.Initialize(); sha.UpdateBigNumbers(&g, NULL); sha.Finalize(); for (int i = 0; i < 20; i++) { hash[i] ^= sha.GetDigest()[i]; } BigNumber t3; t3.SetBinary(hash, 20); sha.Initialize(); sha.UpdateData(m_account->Username); sha.Finalize(); BigNumber t4; t4.SetBinary(sha.GetDigest(), 20); sha.Initialize(); sha.UpdateBigNumbers(&t3, &t4, &s, &A, &B, &m_sessionkey, NULL); sha.Finalize(); BigNumber M; M.SetBinary(sha.GetDigest(), 20); // Compare M1 values. if(memcmp(lp.M1, M.AsByteArray(), 20) != 0) { // Authentication failed. //SendProofError(4, 0); SendChallengeError(CE_NO_ACCOUNT); sLog.outDebug("[AuthLogonProof] M1 values don't match."); return; } // Store sessionkey BigNumber * bs = new BigNumber(m_sessionkey); sInfoCore.SetSessionKey(m_account->AccountId, bs); // let the client know sha.Initialize(); sha.UpdateBigNumbers(&A, &M, &m_sessionkey, 0); sha.Finalize(); SendProofError(0, sha.GetDigest()); sLog.outDebug("[AuthLogonProof] Authentication Success."); // we're authenticated now :) m_authenticated = true; }
HRESULT DataTargetReader::Read32(ULONG32* pUlong32Value) { Align(4); return ReadBytes((BYTE*)pUlong32Value, sizeof(ULONG32)); }
UT_uint16 IE_ImpGraphic_BMP::Read2Bytes(UT_ByteBuf* pBB, UT_uint32 offset) { return ( static_cast<const UT_uint16>(ReadBytes(pBB,offset,2) )); }
bool LoadWavFromFileInMemory(const u8 *fileData, size_t numBytes, std::vector<u8> &dst, bool *isStereo, bool *is16Bit, int *frequency) { if (!fileData || numBytes == 0) { LogError("Null input data passed in"); return false; } if (!isStereo || !is16Bit || !frequency) { LogError("Outputs not set"); return false; } unsigned int index = 0; u8 riff_text[4]; ReadBytes(riff_text, fileData, index, 4); if (!!memcmp(riff_text, "RIFF", 4)) { LogError("No RIFF chunk in WAV data"); return false; } if (index >= numBytes) return false; ReadU32(fileData, index); u8 wave_text[4]; ReadBytes(wave_text, fileData, index, 4); if (!!memcmp(wave_text, "WAVE", 4)) { LogError("No WAVE chunk in WAV data"); return false; } // Search for the fmt chunk for(;;) { if (index >= numBytes) { LogError("No fmt chunk in WAV data"); return false; } u8 chunk_text[4]; ReadBytes(chunk_text, fileData, index, 4); unsigned int chunk_size = ReadU32(fileData, index); if (!memcmp(chunk_text, "fmt ", 4)) break; if (!chunk_size) return false; index += chunk_size; } if (index >= numBytes) return false; u16 format = ReadU16(fileData, index); u16 channels = ReadU16(fileData, index); unsigned int sampleFrequency = ReadU32(fileData, index); /*unsigned int avgbytes =*/ ReadU32(fileData, index); /*unsigned int blockalign =*/ ReadU16(fileData, index); u16 bits = ReadU16(fileData, index); if (format != 1) { LogError("Sound is not PCM data"); return false; } if (channels != 1 && channels != 2) { LogError("Sound is not either mono or stereo"); return false; } if (bits != 8 && bits != 16) { LogError("Sound is not either 8bit or 16bit"); return false; } // Search for the data chunk unsigned int data_length = 0; for(;;) { if (index >= numBytes) { LogError("No data chunk in WAV data"); return false; } u8 chunk_text[4]; ReadBytes(chunk_text, fileData, index, 4); data_length = ReadU32(fileData, index); if (!memcmp(chunk_text, "data", 4)) break; if (!data_length) return false; index += data_length; } if (!data_length) { LogError("Zero numBytes data chunk in WAV data"); return false; } std::ostringstream msg; msg << "Loaded WAV sound with " << channels << " channels " << bits << " bits, frequency " << sampleFrequency << " datasize " << data_length; LogDebug(msg.str()); dst.clear(); dst.insert(dst.end(), &fileData[index], &fileData[index + data_length]); *isStereo = (channels == 2); *is16Bit = (bits == 16); *frequency = sampleFrequency; return true; }
//================================================================================================= axInt16 axDataBufferReader::ReadInt16() { axInt16 i16Result; ReadBytes((axBytes)&i16Result, axSizeOf(axInt16)); return i16Result; }
uint8_t RecvCommand() { uint8_t Cmd; char Username[32]; uint8_t TargetUser = MAX_USERS+1; uint8_t DeviceType; uint16_t DeviceId; uint16_t AlarmId; uint8_t NewDevice; uint8_t UserId; // Read in the one-byte command if (!ReadBytes((unsigned char *)&Cmd, 1)) { return(0); } switch (Cmd) { case CMD_POWER_OFF: SendResp(RESP_SUCCESS, NULL); return(0); break; case CMD_ADD_USER: if (!AddUser()) { SendResp(RESP_ADD_USER_FAILED, NULL); return(1); } SendResp(RESP_SUCCESS, NULL); break; case CMD_DEL_USER: if (!DelUser()) { SendResp(RESP_DEL_USER_FAILED, NULL); return(1); } SendResp(RESP_SUCCESS, NULL); break; case CMD_ADD_DEVICE: // Read in the device type if (!ReadBytes((unsigned char *)&DeviceType, 1)) { return(0); } // Find the next available device slot if ((NewDevice = FindAvailableDevice()) >= MAX_DEVICES) { SendResp(RESP_INVALID_CMD, NULL); return(0); } switch (DeviceType) { case DEVICE_KEYPAD: if (!(DeviceId = NewGenericDevice(DeviceType, NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_SWIPE: if (!(DeviceId = NewGenericDevice(DeviceType, NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_CONTACT: if (!(DeviceId = NewContact(NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_MOTION: if (!(DeviceId = NewMotion(NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_HEAT: if (!(DeviceId = NewHeat(NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_SMOKE: if (!(DeviceId = NewSmoke(NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(0); } break; case DEVICE_ALARM: if (!(DeviceId = NewGenericDevice(DeviceType, NewDevice))) { SendResp(RESP_ADD_DEVICE_FAILED, NULL); return(1); } break; default: SendResp(RESP_ADD_DEVICE_FAILED, NULL); break; } // Send success along with the generated DeviceId SendResp(RESP_SUCCESS, (unsigned char *)&DeviceId); break; case CMD_DEL_DEVICE: // Read in the device id if (!ReadBytes((unsigned char *)&DeviceId, 2)) { return(0); } if (!DeleteDevice(DeviceId)) { SendResp(RESP_DEL_DEVICE_FAILED, NULL); return(1); } SendResp(RESP_SUCCESS, NULL); break; case CMD_GRANT_ACCESS: // Read in the device id if (!ReadBytes((unsigned char *)&DeviceId, 2)) { return(0); } // Read in the user id if (!ReadBytes((unsigned char *)&UserId, 1)) { return(0); } if (!GrantAccess(DeviceId, UserId)) { SendResp(RESP_GRANT_FAILED, NULL); return(1); } SendResp(RESP_SUCCESS, NULL); break; case CMD_UPDATE_DEVICE: // Read in the device id if (!ReadBytes((unsigned char *)&DeviceId, 2)) { return(0); } if (!UpdateDevice(DeviceId)) { SendResp(RESP_UPDATE_DEVICE_FAILED, NULL); return(1); } SendResp(RESP_SUCCESS, NULL); break; case CMD_ADD_DEVICE_TO_ALARM: // Read in the device id if (!ReadBytes((unsigned char *)&DeviceId, 2)) { return(0); } // Read in the alarm id if (!ReadBytes((unsigned char *)&AlarmId, 2)) { return(0); } if (!AddDeviceToAlarm(DeviceId, AlarmId)) { SendResp(RESP_ADD_DEVICE_TO_ALARM_FAILED, NULL); return(0); } SendResp(RESP_SUCCESS, NULL); break; case CMD_LIST_ALARM_CODES: // Read in the device id if (!ReadBytes((unsigned char *)&DeviceId, 2)) { return(0); } if (!ListValidAlarmCodes(DeviceId)) { SendResp(RESP_INVALID_CMD, NULL); return(0); } break; default: SendResp(RESP_INVALID_CMD, NULL); return(1); break; } return(1); }
//================================================================================================= axInt8 axDataBufferReader::ReadInt8() { axInt8 i8Result; ReadBytes((axBytes)&i8Result, axSizeOf(axInt8)); return i8Result; }
//================================================================================================= axUInt8 axDataBufferReader::ReadUInt8() { axUInt8 u8Result; ReadBytes((axBytes)&u8Result, axSizeOf(axUInt8)); return u8Result; }
//================================================================================================= axUInt axDataBufferReader::ReadUInt() { axUInt uResult; ReadBytes((axBytes)&uResult, axSizeOf(axUInt)); return uResult; }
//================================================================================================= axInt axDataBufferReader::ReadInt() { axInt iResult; ReadBytes((axBytes)&iResult, axSizeOf(axInt)); return iResult; }
//================================================================================================= axCharW axDataBufferReader::ReadCharW() { axCharW cResultW; ReadBytes((axBytes)&cResultW, axSizeOf(axCharW)); return cResultW; }
int main(void) { unsigned int type2_addr; unsigned int type2_size; unsigned int type2_length; unsigned char Frame[MAX_FRAME_SIZE]; uint8_t Len; uint8_t EchoLen; pL2Hdr pL2 = (pL2Hdr)Frame; uint8_t i; fd_set readfds; int readyfds; struct timeval timeout; unsigned char *magic_bytes; // negotiate a Type2 POV with the Competition Framework NegotiateType2Pov(&type2_addr, &type2_size, &type2_length); // force the pov to sleep letting the router and cb_3 processes // exchange their echo packets so that SendQueue[0] has the desired // Frame data FD_ZERO(&readfds); FD_SET(STDIN, &readfds); timeout.tv_sec = 2; timeout.tv_usec = 0; fdwait(STDIN+1, &readfds, NULL, &timeout, NULL); // send 13 gratuitous ADP packets for different L3Addr's uint32_t L3Addr = 0x0a010110; for (i = 0; i < 13; i++, L3Addr++) { bzero(Frame, MAX_FRAME_SIZE); Len = BuildAdpResponse(L3Addr, 0x1001, 0x0001, 0x1000, 0, Frame); SendBytes(STDOUT, Frame, Len); } // send one more ADP which will overwrite SendQueue[0] // // the L3addr of the ADP header should point to a L3Addr that // has been previously populated in the router's ADP cache // // the L2Addr of the ADP header should overwrite the 1-byte Valid // with a non-zero value and the 1-byte Age field with 0xfe. bzero(Frame, MAX_FRAME_SIZE); Len = BuildAdpResponse(0x0a010102, 0x0001, 0x0001, 0x1000, 0, Frame); // ^ ^ // Age| |Valid SendBytes(STDOUT, Frame, Len); // Send enough packets to the original L3Addr we populated in the router's // ADP to cause it to age out. // The router will forward it back to VLAN 1, but to an unknown unicast L2Addr // so the switch will drop it for (i = 0; i < 8; i++) { bzero(Frame, MAX_FRAME_SIZE); BuildL4Segment(ECHO_L4ADDR, 0x41, (unsigned char *)"AA", 2, Frame); BuildL3Packet(L3Addr-1, 0x0a010102, Frame); EchoLen = BuildL2Frame(0x0001, 0x1000, 0, Frame); SendBytes(STDOUT, Frame, EchoLen); } // Finally, create ADP entry for the addr we over-wrote // allowing the queued packet to be sent bzero(Frame, MAX_FRAME_SIZE); Len = BuildAdpResponse(0x0a010102, 0x1000, 0x0001, 0x1000, 0, Frame); SendBytes(STDOUT, Frame, Len); // cgc_read in the ADP frame that'll be sent before the target frame bzero(Frame, MAX_FRAME_SIZE); ReadBytes(STDIN, Frame, sizeof(L2Hdr)+sizeof(L2Adjacency)+4); // see if we have a packet to cgc_read FD_ZERO(&readfds); FD_SET(STDIN, &readfds); timeout.tv_sec = 2; timeout.tv_usec = 0; if (fdwait(STDIN+1, &readfds, NULL, &timeout, &readyfds) != 0) { SendBytes(STDOUT, (unsigned char *)"diedie!", 7); bzero(Frame, MAX_FRAME_SIZE); SendBytes(FRAMEWORK, Frame, 4); _terminate(0); } if (readyfds == 0) { SendBytes(STDOUT, (unsigned char *)"diedie!", 7); bzero(Frame, MAX_FRAME_SIZE); SendBytes(FRAMEWORK, Frame, 4); _terminate(0); } // cgc_read the forwarded frame bzero(Frame, MAX_FRAME_SIZE); ReadBytes(STDIN, Frame, sizeof(L2Hdr)+sizeof(L3Hdr)+sizeof(L4Hdr)+4+4); // send the recovered page bytes to the competition framework magic_bytes = Frame+sizeof(L2Hdr)+sizeof(L3Hdr)+sizeof(L4Hdr); SendBytes(FRAMEWORK, magic_bytes, 4); }
Bool16 QTAtom::ReadInt8(UInt64 Offset, UInt8 * Datum) { // // Read and return. return ReadBytes(Offset, (char *)Datum, 1); }
// public string ReadString() [instance] :351 uString* BinaryReader::ReadString() { return ::g::Uno::Runtime::Implementation::TextEncodingImpl::DecodeUtf8(ReadBytes(Read7BitEncodedInt())); }
NTSTATUS SerenumDetectPnpDevice( IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT LowerDevice) { HANDLE Handle = NULL; UCHAR Buffer[256]; ULONG BaudRate; ULONG_PTR TotalBytesReceived = 0; ULONG_PTR Size; ULONG Msr, Purge; ULONG i; BOOLEAN BufferContainsBeginId = FALSE; BOOLEAN BufferContainsEndId = FALSE; SERIAL_LINE_CONTROL Lcr; SERIAL_TIMEOUTS Timeouts; SERIALPERF_STATS PerfStats; NTSTATUS Status; /* Open port */ Status = ObOpenObjectByPointer( LowerDevice, OBJ_KERNEL_HANDLE, NULL, 0, NULL, KernelMode, &Handle); if (!NT_SUCCESS(Status)) goto ByeBye; /* 1. COM port initialization, check for device enumerate */ TRACE_(SERENUM, "COM port initialization, check for device enumerate\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Wait(200); Size = sizeof(Msr); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS, NULL, 0, &Msr, &Size); if (!NT_SUCCESS(Status)) goto ByeBye; if ((Msr & SERIAL_DSR_STATE) == 0) goto DisconnectIdle; /* 2. COM port setup, 1st phase */ TRACE_(SERENUM, "COM port setup, 1st phase\n"); BaudRate = 1200; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE, &BaudRate, sizeof(BaudRate), NULL, 0); if (!NT_SUCCESS(Status)) goto ByeBye; Lcr.WordLength = 7; Lcr.Parity = NO_PARITY; Lcr.StopBits = STOP_BIT_1; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL, &Lcr, sizeof(Lcr), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Wait(200); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Wait(200); /* 3. Wait for response, 1st phase */ TRACE_(SERENUM, "Wait for response, 1st phase\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Timeouts.ReadIntervalTimeout = 0; Timeouts.ReadTotalTimeoutMultiplier = 0; Timeouts.ReadTotalTimeoutConstant = 200; Timeouts.WriteTotalTimeoutMultiplier = Timeouts.WriteTotalTimeoutConstant = 0; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS, &Timeouts, sizeof(Timeouts), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = ReadBytes(LowerDevice, Buffer, sizeof(Buffer), &Size); if (!NT_SUCCESS(Status)) goto ByeBye; if (Size != 0) goto CollectPnpComDeviceId; /* 4. COM port setup, 2nd phase */ TRACE_(SERENUM, "COM port setup, 2nd phase\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Purge = SERIAL_PURGE_RXABORT | SERIAL_PURGE_RXCLEAR; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_PURGE, &Purge, sizeof(ULONG), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Wait(200); /* 5. Wait for response, 2nd phase */ TRACE_(SERENUM, "Wait for response, 2nd phase\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = ReadBytes(LowerDevice, Buffer, 1, &TotalBytesReceived); if (!NT_SUCCESS(Status)) goto ByeBye; if (TotalBytesReceived != 0) goto CollectPnpComDeviceId; Size = sizeof(Msr); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS, NULL, 0, &Msr, &Size); if (!NT_SUCCESS(Status)) goto ByeBye; if ((Msr & SERIAL_DSR_STATE) == 0) goto VerifyDisconnect; else goto ConnectIdle; /* 6. Collect PnP COM device ID */ CollectPnpComDeviceId: TRACE_(SERENUM, "Collect PnP COM device ID\n"); Timeouts.ReadIntervalTimeout = 200; Timeouts.ReadTotalTimeoutMultiplier = 0; Timeouts.ReadTotalTimeoutConstant = 2200; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS, &Timeouts, sizeof(Timeouts), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = ReadBytes(LowerDevice, &Buffer[TotalBytesReceived], sizeof(Buffer) - TotalBytesReceived, &Size); if (!NT_SUCCESS(Status)) goto ByeBye; TotalBytesReceived += Size; Size = sizeof(PerfStats); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_STATS, NULL, 0, &PerfStats, &Size); if (!NT_SUCCESS(Status)) goto ByeBye; if (PerfStats.FrameErrorCount + PerfStats.ParityErrorCount != 0) goto ConnectIdle; for (i = 0; i < TotalBytesReceived; i++) { if (Buffer[i] == BEGIN_ID) BufferContainsBeginId = TRUE; if (Buffer[i] == END_ID) BufferContainsEndId = TRUE; } if (TotalBytesReceived == 1 || BufferContainsEndId) { if (IsValidPnpIdString(Buffer, TotalBytesReceived)) { Status = ReportDetectedPnpDevice(Buffer, TotalBytesReceived); goto ByeBye; } goto ConnectIdle; } if (!BufferContainsBeginId) goto ConnectIdle; if (!BufferContainsEndId) goto ConnectIdle; Size = sizeof(Msr); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_GET_MODEMSTATUS, NULL, 0, &Msr, &Size); if (!NT_SUCCESS(Status)) goto ByeBye; if ((Msr & SERIAL_DSR_STATE) == 0) goto VerifyDisconnect; /* 7. Verify disconnect */ VerifyDisconnect: TRACE_(SERENUM, "Verify disconnect\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Wait(5000); goto DisconnectIdle; /* 8. Connect idle */ ConnectIdle: TRACE_(SERENUM, "Connect idle\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; BaudRate = 300; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE, &BaudRate, sizeof(BaudRate), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Lcr.WordLength = 7; Lcr.Parity = NO_PARITY; Lcr.StopBits = STOP_BIT_1; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL, &Lcr, sizeof(Lcr), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; if (TotalBytesReceived == 0) Status = STATUS_DEVICE_NOT_CONNECTED; else Status = STATUS_SUCCESS; goto ByeBye; /* 9. Disconnect idle */ DisconnectIdle: TRACE_(SERENUM, "Disconnect idle\n"); /* FIXME: report to OS device removal, if it was present */ Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; BaudRate = 300; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE, &BaudRate, sizeof(BaudRate), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Lcr.WordLength = 7; Lcr.Parity = NO_PARITY; Lcr.StopBits = STOP_BIT_1; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL, &Lcr, sizeof(Lcr), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = STATUS_DEVICE_NOT_CONNECTED; ByeBye: /* Close port */ if (Handle) ZwClose(Handle); return Status; }
UT_uint32 IE_ImpGraphic_BMP::Read4Bytes(UT_ByteBuf* pBB, UT_uint32 offset) { return ( ReadBytes(pBB,offset,4) ); }
NTSTATUS SerenumDetectLegacyDevice( IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT LowerDevice) { HANDLE Handle = NULL; ULONG Fcr, Mcr; ULONG BaudRate; ULONG Command; SERIAL_TIMEOUTS Timeouts; SERIAL_LINE_CONTROL LCR; ULONG i, Count = 0; UCHAR Buffer[16]; UNICODE_STRING DeviceDescription; UNICODE_STRING DeviceId; UNICODE_STRING InstanceId; UNICODE_STRING HardwareIds; UNICODE_STRING CompatibleIds; NTSTATUS Status; TRACE_(SERENUM, "SerenumDetectLegacyDevice(DeviceObject %p, LowerDevice %p)\n", DeviceObject, LowerDevice); RtlZeroMemory(Buffer, sizeof(Buffer)); /* Open port */ Status = ObOpenObjectByPointer( LowerDevice, OBJ_KERNEL_HANDLE, NULL, 0, NULL, KernelMode, &Handle); if (!NT_SUCCESS(Status)) return Status; /* Reset UART */ TRACE_(SERENUM, "Reset UART\n"); Mcr = 0; /* MCR: DTR/RTS/OUT2 off */ Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL, &Mcr, sizeof(Mcr), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Set communications parameters */ TRACE_(SERENUM, "Set communications parameters\n"); /* DLAB off */ Fcr = 0; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_FIFO_CONTROL, &Fcr, sizeof(Fcr), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Set serial port speed */ BaudRate = 1200; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_BAUD_RATE, &BaudRate, sizeof(BaudRate), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Set LCR */ LCR.WordLength = 7; LCR.Parity = NO_PARITY; LCR.StopBits = STOP_BITS_2; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL, &LCR, sizeof(LCR), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Flush receive buffer */ TRACE_(SERENUM, "Flush receive buffer\n"); Command = SERIAL_PURGE_RXCLEAR; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL, &Command, sizeof(Command), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Wait 100 ms */ Wait(100); /* Enable DTR/RTS */ TRACE_(SERENUM, "Enable DTR/RTS\n"); Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS, NULL, 0, NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Set timeout to 500 microseconds */ TRACE_(SERENUM, "Set timeout to 500 microseconds\n"); Timeouts.ReadIntervalTimeout = 100; Timeouts.ReadTotalTimeoutMultiplier = 0; Timeouts.ReadTotalTimeoutConstant = 500; Timeouts.WriteTotalTimeoutMultiplier = Timeouts.WriteTotalTimeoutConstant = 0; Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS, &Timeouts, sizeof(Timeouts), NULL, NULL); if (!NT_SUCCESS(Status)) goto ByeBye; /* Fill the read buffer */ TRACE_(SERENUM, "Fill the read buffer\n"); Status = ReadBytes(LowerDevice, Buffer, sizeof(Buffer)/sizeof(Buffer[0]), (PVOID)&Count); if (!NT_SUCCESS(Status)) goto ByeBye; RtlInitUnicodeString(&DeviceId, L"Serenum\\Mouse"); RtlInitUnicodeString(&InstanceId, L"0000"); /* FIXME */ for (i = 0; i < Count; i++) { if (Buffer[i] == 'B') { /* Sign for Microsoft Ballpoint */ /* Hardware id: *PNP0F09 * Compatible id: *PNP0F0F, SERIAL_MOUSE */ RtlInitUnicodeString(&DeviceDescription, L"Microsoft Ballpoint device"); SerenumInitMultiSzString(&HardwareIds, "*PNP0F09", NULL); SerenumInitMultiSzString(&CompatibleIds, "*PNP0F0F", "SERIAL_MOUSE", NULL); Status = ReportDetectedDevice(DeviceObject, &DeviceDescription, &DeviceId, &InstanceId, &HardwareIds, &CompatibleIds); RtlFreeUnicodeString(&HardwareIds); RtlFreeUnicodeString(&CompatibleIds); goto ByeBye; } else if (Buffer[i] == 'M') { /* Sign for Microsoft Mouse protocol followed by button specifier */ if (i == sizeof(Buffer) - 1) { /* Overflow Error */ Status = STATUS_DEVICE_NOT_CONNECTED; goto ByeBye; } switch (Buffer[i + 1]) { case '3': /* Hardware id: *PNP0F08 * Compatible id: SERIAL_MOUSE */ RtlInitUnicodeString(&DeviceDescription, L"Microsoft Mouse with 3-buttons"); SerenumInitMultiSzString(&HardwareIds, "*PNP0F08", NULL); SerenumInitMultiSzString(&CompatibleIds, "SERIAL_MOUSE", NULL); break; default: /* Hardware id: *PNP0F01 * Compatible id: SERIAL_MOUSE */ RtlInitUnicodeString(&DeviceDescription, L"Microsoft Mouse with 2-buttons or Microsoft Wheel Mouse"); SerenumInitMultiSzString(&HardwareIds, "*PNP0F01", NULL); SerenumInitMultiSzString(&CompatibleIds, "SERIAL_MOUSE", NULL); break; } Status = ReportDetectedDevice(DeviceObject, &DeviceDescription, &DeviceId, &InstanceId, &HardwareIds, &CompatibleIds); RtlFreeUnicodeString(&HardwareIds); RtlFreeUnicodeString(&CompatibleIds); goto ByeBye; } } Status = STATUS_DEVICE_NOT_CONNECTED; ByeBye: /* Close port */ if (Handle) ZwClose(Handle); return Status; }
// Read a command from the CRS uint8_t ReadCmd(void) { Command Cmd; uint32_t *NewNodeNames; pEdgeArray NewEdges; uint32_t i; pNode NewNode; pEdge NewEdge; pEdge ExistingEdge; uint8_t NodeCount; uint32_t *SPT; // read in the basic command header if (ReadBytes((unsigned char *)&Cmd, sizeof(Command)) != sizeof(Command)) { return(0); } if (Cmd.Action == CMD_SEND_NODES) { // read in the indicated number of Nodes #ifdef PATCHED_1 if ((Cmd.NumElements + NumNodes) > MAX_NODES) { #else if (Cmd.NumElements > MAX_NODES) { #endif ReadNull(sizeof(uint32_t)*Cmd.NumElements); SendErrorResponse(RESP_ERROR_TOO_MANY_NODES); return(0); } if ((NewNodeNames = (uint32_t *)calloc(sizeof(uint32_t)*Cmd.NumElements)) == NULL) { DestroyNodes(); DestroyEdges(); _terminate(1); } if (ReadBytes((unsigned char *)NewNodeNames, sizeof(uint32_t)*Cmd.NumElements) != sizeof(uint32_t)*Cmd.NumElements) { free(NewNodeNames); return(0); } // make sure none of the new node names exist already for (i = 0; i < Cmd.NumElements; i++) { if (FindNode(NewNodeNames[i]) != NULL) { free(NewNodeNames); SendErrorResponse(RESP_ERROR_DUPLICATE_NODE); return(0); } } // Create the new nodes for (i = 0; i < Cmd.NumElements; i++) { // create a new node if ((NewNode = (pNode)calloc(sizeof(Node))) == NULL) { free(NewNodeNames); DestroyNodes(); DestroyEdges(); _terminate(1); } NewNode->Name = NewNodeNames[i]; NewNode->Distance = SIZE_MAX; // Add it to the graph if (!AddNode(NewNode)) { free(NewNodeNames); DestroyNodes(); DestroyEdges(); _terminate(1); } } // done creating new nodes free(NewNodeNames); } else if (Cmd.Action == CMD_SEND_EDGES) { // read in the indicated number of Edges if ((Cmd.NumElements + NumEdges) > MAX_EDGES) { ReadNull(sizeof(EdgeArray)*Cmd.NumElements); SendErrorResponse(RESP_ERROR_TOO_MANY_EDGES); return(0); } if ((NewEdges = (pEdgeArray)calloc(sizeof(EdgeArray)*Cmd.NumElements)) == NULL) { DestroyNodes(); DestroyEdges(); _terminate(1); } if (ReadBytes((unsigned char *)NewEdges, sizeof(EdgeArray)*Cmd.NumElements) != sizeof(EdgeArray)*Cmd.NumElements) { free(NewEdges); return(0); } // Create the new edges for (i = 0; i < Cmd.NumElements; i++) { // create a new Edge if ((NewEdge = (pEdge)calloc(sizeof(Edge))) == NULL) { free(NewEdges); DestroyNodes(); DestroyEdges(); _terminate(1); } // make sure the starting and ending nodes exist if ((NewEdge->NodeA = FindNode(NewEdges[i].NodeA)) == NULL) { SendErrorResponse(RESP_ERROR_INVALID_NODE); free(NewEdge); free(NewEdges); DestroyNodes(); DestroyEdges(); _terminate(1); } if ((NewEdge->NodeZ = FindNode(NewEdges[i].NodeZ)) == NULL) { SendErrorResponse(RESP_ERROR_INVALID_NODE); free(NewEdge); free(NewEdges); DestroyNodes(); DestroyEdges(); _terminate(1); } // offset the weight by a fixed magic_page-based value NewEdge->Weight = NewEdges[i].Weight + rand_page[NumNodes]; // see if one already exists if ((ExistingEdge = FindEdge(NewEdge->NodeA, NewEdge->NodeZ)) != NULL) { if (ExistingEdge->Weight > NewEdge->Weight) { ExistingEdge->Weight = NewEdge->Weight; } // keep the existing edge free(NewEdge); continue; } // Add it to the graph if (!AddEdge(NewEdge)) { free(NewEdge); free(NewEdges); DestroyNodes(); DestroyEdges(); _terminate(1); } } } else if (Cmd.Action == CMD_RUN_SPT) { if ((SPT = FindSpt(Cmd.StartingNode, Cmd.EndingNode, &NodeCount)) == NULL) { // unable to find SPT SendErrorResponse(RESP_ERROR_SPT_FAIL); return(0); } SendResponse(RESP_NODE_SET, NodeCount, SPT); free(SPT); } else { SendErrorResponse(RESP_ERROR_INVALID_CMD); return(0); } return(1); }
void CInArchive::GetNextFolderItem(CFolder &folder) { CNum numCoders = ReadNum(); folder.Coders.Clear(); folder.Coders.Reserve((int)numCoders); CNum numInStreams = 0; CNum numOutStreams = 0; CNum i; for (i = 0; i < numCoders; i++) { folder.Coders.Add(CCoderInfo()); CCoderInfo &coder = folder.Coders.Back(); { Byte mainByte = ReadByte(); int idSize = (mainByte & 0xF); Byte longID[15]; ReadBytes(longID, idSize); if (idSize > 8) ThrowUnsupported(); UInt64 id = 0; for (int j = 0; j < idSize; j++) id |= (UInt64)longID[idSize - 1 - j] << (8 * j); coder.MethodID = id; if ((mainByte & 0x10) != 0) { coder.NumInStreams = ReadNum(); coder.NumOutStreams = ReadNum(); } else { coder.NumInStreams = 1; coder.NumOutStreams = 1; } if ((mainByte & 0x20) != 0) { CNum propsSize = ReadNum(); coder.Props.SetCapacity((size_t)propsSize); ReadBytes((Byte *)coder.Props, (size_t)propsSize); } if ((mainByte & 0x80) != 0) ThrowUnsupported(); } numInStreams += coder.NumInStreams; numOutStreams += coder.NumOutStreams; } CNum numBindPairs = numOutStreams - 1; folder.BindPairs.Clear(); folder.BindPairs.Reserve(numBindPairs); for (i = 0; i < numBindPairs; i++) { CBindPair bp; bp.InIndex = ReadNum(); bp.OutIndex = ReadNum(); folder.BindPairs.Add(bp); } if (numInStreams < numBindPairs) ThrowUnsupported(); CNum numPackStreams = numInStreams - numBindPairs; folder.PackStreams.Reserve(numPackStreams); if (numPackStreams == 1) { for (i = 0; i < numInStreams; i++) if (folder.FindBindPairForInStream(i) < 0) { folder.PackStreams.Add(i); break; } if (folder.PackStreams.Size() != 1) ThrowUnsupported(); } else for (i = 0; i < numPackStreams; i++) folder.PackStreams.Add(ReadNum()); }
HRESULT DataTargetReader::Read8(BYTE* pByteValue) { return ReadBytes(pByteValue, 1); }
XBOX::VError VHTTPWebsocketHandler::ReadHeader(bool* found) { VError l_err; memset(&fFrame,0,sizeof(ws_frame_t)); *found = false; fFrame.buf_len = 2; //printf("ReadHeader called\n"); l_err = ReadBytes((void *)fFrame.header, &fFrame.buf_len); if (!l_err && fFrame.buf_len) { // extensions not handled if (fFrame.header[0] & 0x70) { DebugMsg("VHTTPWebsocketHandler::ReadHeader RFC6455 EXTENSIONS NOT HANDLED!!!!\n"); l_err = VE_INVALID_PARAMETER; } if (!l_err) { fFrame.opcode = (ws_opcode_t)(fFrame.header[0] & 0x0F); fFrame.masked = (fFrame.header[1] & 0x80); fFrame.len = (sLONG8)(fFrame.header[1] & 0x7F); if (fFrame.len == 127) { fFrame.buf_len = 8; l_err = ReadBytes((void *)(fFrame.header+2), &fFrame.buf_len); if ( !l_err && (fFrame.buf_len != 8) ) { l_err = VE_STREAM_CANNOT_READ; } if (!l_err) { fFrame.len = 0; for(int l_i=0;l_i<8;l_i+=2) { fFrame.len = 65536*fFrame.len + (256*fFrame.header[2+l_i]+fFrame.header[3+l_i]); } DebugMsg("ReadHeader frame.len=%lld\n",fFrame.len); } } else { if (fFrame.len == 126) { fFrame.buf_len = 2; l_err = ReadBytes((void *)(fFrame.header+2), &fFrame.buf_len); if ( !l_err && (fFrame.buf_len != 2) ) { l_err = VE_STREAM_CANNOT_READ; } if (!l_err) { fFrame.len = 256*fFrame.header[2]+fFrame.header[3]; DebugMsg("ReadHeader frame.len=%d\n",fFrame.len); } } else { DebugMsg("ReadHeader frame.len=%d\n",fFrame.len); } } if (!l_err && fFrame.masked) { fFrame.buf_len = 4; l_err = ReadBytes((void *)fFrame.msk, &fFrame.buf_len); if ( !l_err && (fFrame.buf_len != 4) ) { l_err = VE_STREAM_CANNOT_READ; } } *found = true; } } return l_err; }
HRESULT DataTargetReader::Read64(ULONG64* pUlong64Value) { Align(8); return ReadBytes((BYTE*)pUlong64Value, sizeof(ULONG64)); }
XBOX::VError VHTTPWebsocketHandler::ReadMessage( void* inData, uLONG* ioLength, bool* outIsTerminated ) { bool l_header_found; uLONG length; VError l_err; if (!fEndpt) { xbox_assert((fEndpt != NULL)); return VE_INVALID_PARAMETER; } l_err = VE_OK; if (!fBytesToRead) { l_err = ReadHeader(&l_header_found); if (l_err) { DebugMsg("ERR2\n"); } if (!l_err && !l_header_found) { *ioLength = 0; } // not fragmented ? if (!l_err && (*ioLength) && (fFrame.header[0] & 0x80)) { fBytesToRead = fFrame.len; fCurt = XBOX_LONG8(0); switch(fFrame.opcode) { case CONTINUATION_FRAME: DebugMsg("ERR3\n"); l_err = VE_UNIMPLEMENTED; break; case CONNEXION_CLOSE: if (fFrame.len >= 126) { DebugMsg("ERR4\n"); l_err = VE_INVALID_PARAMETER; } else { l_err = VE_STREAM_EOF; /*// close the socket goto NOK; while (!l_err && (fBytesToRead > 0)) { length = (uLONG)( *ioLength >=fBytesToRead ? fBytesToRead : *ioLength); l_err = ReadBytes(inData,&length); if (l_err) { DebugMsg("ERR 5\n"); } else { fBytesToRead -= length; *ioLength = length; } }*/ } break; case TEXT_FRAME: case BIN_FRAME: break; default: break; } } else { if (!l_err && *(ioLength) ) { DebugMsg("Fragmentation not handled ERR6\n"); } } } //DebugMsg("ReadMessage req_len=%d ToRead=%lld\n",*ioLength,fBytesToRead); if (!l_err && fBytesToRead) { //printf("...... bef ReadMessage req_len=%d ToRead=%lld\n",*ioLength,fBytesToRead); *ioLength = ( *ioLength >=fBytesToRead ? ((uLONG)fBytesToRead) : *ioLength); //printf("...... aft ReadMessage req_len=%d ToRead=%lld\n",*ioLength,fBytesToRead); l_err = ReadBytes(inData,ioLength); if (l_err) { DebugMsg("ERR1\n"); } else { fBytesToRead -= *ioLength; //printf("...... ....... aft ReadMessage read_len=%d ToRead=%lld\n",*ioLength,fBytesToRead); if (fFrame.masked) { for(uLONG l_i=0; l_i<*ioLength; l_i++) { ((unsigned char *)inData)[l_i] ^= fFrame.msk[fCurt % 4]; fCurt++; } } *outIsTerminated = !(fBytesToRead); } } if (l_err) { /*fEndpt = NULL;*/ Close(); } return l_err; }
HRESULT CUnpacker::Unpack(IInStream *inStream, const CResource &resource, ISequentialOutStream *outStream, ICompressProgressInfo *progress) { RINOK(inStream->Seek(resource.Offset, STREAM_SEEK_SET, NULL)); CLimitedSequentialInStream *limitedStreamSpec = new CLimitedSequentialInStream(); CMyComPtr<ISequentialInStream> limitedStream = limitedStreamSpec; limitedStreamSpec->SetStream(inStream); if (!copyCoder) { copyCoderSpec = new NCompress::CCopyCoder; copyCoder = copyCoderSpec; } if (!resource.IsCompressed()) { if (resource.PackSize != resource.UnpackSize) return S_FALSE; limitedStreamSpec->Init(resource.PackSize); return copyCoder->Code(limitedStreamSpec, outStream, NULL, NULL, progress); } if (resource.UnpackSize == 0) return S_OK; UInt64 numChunks = (resource.UnpackSize + kChunkSize - 1) >> kChunkSizeBits; unsigned entrySize = ((resource.UnpackSize > (UInt64)1 << 32) ? 8 : 4); UInt64 sizesBufSize64 = entrySize * (numChunks - 1); UInt32 sizesBufSize = (UInt32)sizesBufSize64; if (sizesBufSize != sizesBufSize64) return E_OUTOFMEMORY; if (sizesBufSize > sizesBuf.GetCapacity()) { sizesBuf.Free(); sizesBuf.SetCapacity(sizesBufSize); } RINOK(ReadBytes(inStream, (Byte *)sizesBuf, sizesBufSize)); const Byte *p = (const Byte *)sizesBuf; if (!lzxDecoder) { lzxDecoderSpec = new NCompress::NLzx::CDecoder(true); lzxDecoder = lzxDecoderSpec; RINOK(lzxDecoderSpec->SetParams(kChunkSizeBits)); } UInt64 baseOffset = resource.Offset + sizesBufSize64; UInt64 outProcessed = 0; for (UInt32 i = 0; i < (UInt32)numChunks; i++) { UInt64 offset = 0; if (i > 0) { if (entrySize == 4) offset = GetUInt32FromMem(p); else offset = GetUInt64FromMem(p); p += entrySize; } UInt64 nextOffset = resource.PackSize - sizesBufSize64; if (i + 1 < (UInt32)numChunks) if (entrySize == 4) nextOffset = GetUInt32FromMem(p); else nextOffset = GetUInt64FromMem(p); if (nextOffset < offset) return S_FALSE; RINOK(inStream->Seek(baseOffset + offset, STREAM_SEEK_SET, NULL)); UInt64 inSize = nextOffset - offset; limitedStreamSpec->Init(inSize); if (progress) { RINOK(progress->SetRatioInfo(&offset, &outProcessed)); } UInt32 outSize = kChunkSize; if (outProcessed + outSize > resource.UnpackSize) outSize = (UInt32)(resource.UnpackSize - outProcessed); UInt64 outSize64 = outSize; lzxDecoderSpec->SetKeepHistory(false); ICompressCoder *coder = (inSize == outSize) ? copyCoder : lzxDecoder; RINOK(coder->Code(limitedStreamSpec, outStream, NULL, &outSize64, NULL)); outProcessed += outSize; } return S_OK; }
NS_IMETHODIMP nsBinaryInputStream::ReadByteArray(uint32_t aLength, uint8_t* *_rval) { return ReadBytes(aLength, reinterpret_cast<char **>(_rval)); }
static HRESULT ReadWavHeader(FILE *fpr, WWMFPcmFormat *format_return, DWORD *dataBytes_return) { HRESULT hr = E_FAIL; BYTE buff[16]; int chunkBytes = 0; int fmtChunkSize = 0; short shortValue; int intValue; HRG(ReadBytes(fpr, 12U, buff)); if (0 != memcmp(buff, "RIFF", 4)) { printf("file is not riff wave file\n"); goto end; } if (0 != memcmp(&buff[8], "WAVE", 4)) { printf("file is not riff wave file\n"); goto end; } for (;;) { HRG(ReadBytes(fpr, 4U, buff)); if (0 == memcmp(buff, "fmt ", 4)) { // fmt chunk // chunkSize size==4 HRG(ReadInt32(fpr, &fmtChunkSize)); if (16 != fmtChunkSize && 18 != fmtChunkSize && 40 != fmtChunkSize) { printf("unrecognized format"); goto end; } // audioFormat size==2 HRG(ReadInt16(fpr, &shortValue)); if (1 == shortValue) { format_return->sampleFormat = WWMFBitFormatInt; } else if (3 == shortValue) { format_return->sampleFormat = WWMFBitFormatFloat; } else if (0xfffe == (unsigned short)shortValue) { // SampleFormat is written on WAVEFORMATEXTENSIBLE format_return->sampleFormat = WWMFBitFormatUnknown; } else { printf("unrecognized format"); goto end; } // numChannels size==2 HRG(ReadInt16(fpr, &shortValue)); format_return->nChannels = shortValue; // sampleRate size==4 HRG(ReadInt32(fpr, &intValue)); format_return->sampleRate = intValue; // byteRate size==4 HRG(ReadInt32(fpr, &intValue)); // blockAlign size==2 HRG(ReadInt16(fpr, &shortValue)); // bitspersample size==2 HRG(ReadInt16(fpr, &shortValue)); format_return->bits = shortValue; format_return->validBitsPerSample = shortValue; if (16 < fmtChunkSize) { // subchunksize HRG(ReadInt16(fpr, &shortValue)); if (0 == shortValue) { hr = S_OK; goto end; } else if (22 == shortValue) { // validbitspersample HRG(ReadInt16(fpr, &shortValue)); format_return->validBitsPerSample = shortValue; // dwChannelMask HRG(ReadInt32(fpr, (int*)&format_return->dwChannelMask)); // format GUID HRG(ReadBytes(fpr, 16U, buff)); if (0 == memcmp(buff, &MFAudioFormat_Float, 16)) { format_return->sampleFormat = WWMFBitFormatFloat; } else if (0 == memcmp(buff, &MFAudioFormat_PCM, 16)) { format_return->sampleFormat = WWMFBitFormatInt; } else { printf("unrecognized format guid"); goto end; } } else { printf("unrecognized format"); goto end; } } } else if (0 == memcmp(buff, "data", 4)) { // data chunk HRG(ReadInt32(fpr, (int*)dataBytes_return)); break; } else { // skip this chunk HRG(ReadInt32(fpr, &chunkBytes)); if (chunkBytes < 4) { printf("E: chunk bytes == %d\n", chunkBytes); goto end; } fseek(fpr, chunkBytes, SEEK_CUR); } } end: if (S_OK == hr && format_return->sampleFormat == WWMFBitFormatUnknown) { printf("unrecognized format"); hr = E_FAIL; } return hr; }
//================================================================================================= axByte axDataBufferReader::ReadByte() { axByte bResult; ReadBytes((axBytes)&bResult, axSizeOf(axByte)); return bResult; }